From 042f80cc2fc677d9da1bd378caca0248e9e72751 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 18:39:52 -0700 Subject: [PATCH 1/3] chore(quest): claim quest/m3/ts-iter-clone.md Quest-Claim: 36120e2558fbb4d9 From c59459db1d374d815ea1d18c87a3b634656f32ba Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 19:20:39 -0700 Subject: [PATCH 2/3] feat(ts): clone std's iterators and adaptors Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 2 +- quest/m3/ts-iter-clone.md | 26 - quest/m3/ts-iter-cycle.md | 17 + ts/README.md | 12 +- ts/fixtures/lang/expected/clones.Countdown.ts | 23 + ts/fixtures/lang/expected/clones.Logged.ts | 41 + ts/fixtures/lang/expected/clones.Plan.ts | 18 + ts/fixtures/lang/expected/clones.ts | 7365 +++++++++++++++++ ts/fixtures/lang/expected/core/option.ts | 15 + ts/fixtures/lang/expected/harness.ts | 7 +- ts/fixtures/lang/expected/iters.ts | 8 +- ts/fixtures/lang/expected/lib.ts | 5 + ts/fixtures/lang/expected/slices.ts | 8 +- ts/fixtures/lang/expected/wrappers.ts | 2 +- ts/fixtures/lang/src/clones.rs | 530 ++ ts/fixtures/lang/src/harness.rs | 9 +- ts/fixtures/lang/src/lib.rs | 1 + ts/runtime/rt/collections.ts | 85 +- ts/runtime/rt/iter.ts | 178 +- ts/runtime/rt/str.ts | 40 +- ts/runtime/rt/task.ts | 19 +- ts/src/lower/collections.rs | 6 +- ts/src/lower/iter.rs | 107 +- ts/src/lower/library.rs | 30 +- ts/src/lower/mir/mod.rs | 2 +- ts/src/lower/mir/place.rs | 24 +- ts/src/lower/mir/rvalue.rs | 56 +- ts/src/lower/mod.rs | 29 +- 28 files changed, 8555 insertions(+), 110 deletions(-) delete mode 100644 quest/m3/ts-iter-clone.md create mode 100644 quest/m3/ts-iter-cycle.md create mode 100644 ts/fixtures/lang/expected/clones.Countdown.ts create mode 100644 ts/fixtures/lang/expected/clones.Logged.ts create mode 100644 ts/fixtures/lang/expected/clones.Plan.ts create mode 100644 ts/fixtures/lang/expected/clones.ts create mode 100644 ts/fixtures/lang/src/clones.rs diff --git a/quest/m3/README.md b/quest/m3/README.md index 874a44399..428e47307 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -35,5 +35,5 @@ generic std gap is planned here even when moq never calls it. - [A parameter read only where lowering leaves nothing](/quest/m3/ts-unread-params.md) - an instance whose lowering drops every read of a parameter marks it unused, so `tsc` accepts it - [Zip's next_back in constant time](/quest/m3/ts-zip-back.md) - a reversed zip of random-access iterators skips the longer side's excess at once - [Unbounded ranges as iterators adaptors take](/quest/m3/ts-range-from-iter.md) - `iter.zip(0..)` and other adaptors taking a `start..` type-check -- [Cloning std's iterators](/quest/m3/ts-iter-clone.md) - `clone` of std's iterators and adaptors translates, each clone reading on independently - [The TS benchmark's A/B route as documented](/quest/m3/ts-bench-route.md) - the README's A/B bench command runs as written +- [Cycling std's iterators](/quest/m3/ts-iter-cycle.md) - `Iterator::cycle` translates, cloning its iterator each time it ends diff --git a/quest/m3/ts-iter-clone.md b/quest/m3/ts-iter-clone.md deleted file mode 100644 index 1d29caea5..000000000 --- a/quest/m3/ts-iter-clone.md +++ /dev/null @@ -1,26 +0,0 @@ -# [S] Cloning std's iterators - -## Goal - -[rust2-ts](/ts/README.md) translates `clone` of std's iterators and adaptors, such as a -`zip`, a `map`, a `chars`, and a set operation's iterator, the clone reading on from where -the original was, independently of it, proven by differential tests against native Rust. - -## Plan - -Found by [#314](https://github.com/moq-dev/rust2/pull/314) writing its zip fixture, and -by [#302](https://github.com/moq-dev/rust2/pull/302), where the set operations' -iterators refuse `clone` as other std iterators do. Planned without a moq consumer, under -the maintainer's 2026-10-27 decision that rust2 aims to support all of std. - -- An `rt.Iter` that reads a collection by position clones its position; one that reads - another iterator clones that one too, as std's derived `Clone` does, and a closure an - adaptor holds is cloned as Rust clones the closure's captures. -- A clone must not share state the original advances: test both read after the clone, - in turns, including partially read ones, a zip past its shorter side, and adaptors whose - closures capture values that drop. -- `Debug` of std's iterators reads what each has left through `rt.Iter.remaining()` - ([#317](https://github.com/moq-dev/rust2/pull/317)), where std's iterates a clone; once - clones exist, weigh replacing `remaining()` with them. - -Public API: the translator's output. diff --git a/quest/m3/ts-iter-cycle.md b/quest/m3/ts-iter-cycle.md new file mode 100644 index 000000000..758450aec --- /dev/null +++ b/quest/m3/ts-iter-cycle.md @@ -0,0 +1,17 @@ +# [S] Cycling std's iterators + +## Goal + +`Iterator::cycle` translates, proven by a differential test against native Rust, which +the reject fixture's `cycled` refuses today. + +## Plan + +Found by [#322](https://github.com/moq-dev/rust2/pull/322), which gave each `rt.Iter` +that std implements `Clone` for a `clone(h)` and the translation its `rt.Clones`. std's +`Cycle` holds its iterator as it was and a clone it reads, which it clones again each +time that ends, so an adaptor of the runtime's can hold the original and its `Clones` +and clone it the same way. Planned without a moq consumer, under the maintainer's +2026-10-27 decision that rust2 aims to support all of std. + +Public API: the translator's output. diff --git a/ts/README.md b/ts/README.md index 8412841e8..fe624a37b 100644 --- a/ts/README.md +++ b/ts/README.md @@ -103,7 +103,7 @@ crate translation reaches is refused, and so are two versions of one crate it re | `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` | `rt.Ordering`, which is `-1`, `0`, or `1`; `rt.Hasher`; `rt.RandomState`, the keys of the `DefaultHasher` it builds, never changed once made | | `Duration` | `rt.Duration`: `{ secs, nanos }`, std's whole seconds as an `rt.u64` and the nanoseconds past them, never changed once made | -| closure | an arrow function, with `[Symbol.dispose]` if it owns a value that drops | +| 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, as a closure is typed: a `()` result is `undefined`, where a declared function returns `void` | | `&dyn Trait`, `&mut dyn Trait`, `Box`, `Arc` | an object with the trait's methods, its supertraits' included: `shape.area$Shape()`; behind an `Arc`, an `rt.ArcDyn` sharing the count of the `Arc` it was made from | | `dyn Any` | an instance of the class its value's type was wrapped in, which a downcast checks for: `a instanceof Any.Square ? a.v : undefined` | @@ -238,6 +238,16 @@ bound `undefined` for `None`, and a `collect` or `extend` into a `Vec`, `VecDequ std's capacity overflow past the most it holds. Capacity isn't modeled, so a collection an `extend` starts from is taken as full. +`clone` of one of std's iterators or adaptors is its `rt.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 +owns its items holds, an adaptor's closure, or the crate's own iterator, it clones by +what the translation gives it, as `it.clone({ v: Item.clone$Clone })`. A closure clones as Rust +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. + 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, or an array or slice of chars, as in `rt.strSplit(s, "/")`, takes the text or the closure, which it calls on each char it reads, in the order std reads them. An offset it diff --git a/ts/fixtures/lang/expected/clones.Countdown.ts b/ts/fixtures/lang/expected/clones.Countdown.ts new file mode 100644 index 000000000..97411ac04 --- /dev/null +++ b/ts/fixtures/lang/expected/clones.Countdown.ts @@ -0,0 +1,23 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function clone$Clone(self: Countdown): Countdown { + return { _0: self._0 }; +} + +/** The crate's own iterator, which std's adaptors hold by value. */ +export interface Countdown { + _0: rt.u8; +} + +export function next$Iterator(self: Countdown): rt.u8 | rt.Done { + const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); + if (_2 !== undefined) { + self._0 = _2; + return self._0; + } + return rt.DONE; +} + +//# sourceMappingURL=clones.Countdown.ts.map diff --git a/ts/fixtures/lang/expected/clones.Logged.ts b/ts/fixtures/lang/expected/clones.Logged.ts new file mode 100644 index 000000000..34eaf3ca2 --- /dev/null +++ b/ts/fixtures/lang/expected/clones.Logged.ts @@ -0,0 +1,41 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.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>; + + constructor(id: rt.u8, log: rt.Arc>) { + this.id = id; + this.log = log; + } + + [Symbol.dispose](): void { + drop$Drop(this); + this.log[Symbol.dispose](); + } +} + +export function id(self: Logged): rt.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)); +} + +export function drop$Drop(self: Logged): void { + const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); + rt.byteVecPush(_5.value, self.id); + rt.refMutRelease(_5); +} + +//# sourceMappingURL=clones.Logged.ts.map diff --git a/ts/fixtures/lang/expected/clones.Plan.ts b/ts/fixtures/lang/expected/clones.Plan.ts new file mode 100644 index 000000000..25aba7bf5 --- /dev/null +++ b/ts/fixtures/lang/expected/clones.Plan.ts @@ -0,0 +1,18 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { unwrapOr$0r2bmpr } from "./core/option.ts"; + +/** What `turns` reads by: the case's bytes, each step's taken in order. */ +export interface Plan { + data: rt.ByteSlice; + at: rt.usize; +} + +export function next(self: Plan): rt.u8 { + const b: rt.u8 = unwrapOr$0r2bmpr(rt.byteSliceGet(self.data, rt.usizeRem(self.at, rt.max(self.data.length, 1))), 0); + self.at = rt.usizeAdd(self.at, 1); + return b ^ rt.u8WrappingMul(self.at & 0xff, 29); +} + +//# sourceMappingURL=clones.Plan.ts.map diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts new file mode 100644 index 000000000..c8a7df96b --- /dev/null +++ b/ts/fixtures/lang/expected/clones.ts @@ -0,0 +1,7365 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { drop$Vec_Logged } from "./lib.ts"; +import * as Countdown from "./clones.Countdown.ts"; +import * as Logged from "./clones.Logged.ts"; +import * as Plan from "./clones.Plan.ts"; +import { unwrapOr$0r2bmpr, map$0y3liwu, mapOr$1yabfom, mapOr$1surhce, mapOr$02k4ito } 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); +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Bytes_iters_closure49_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Chain_Iter_u8_Skip_Rev_Iter_u8_iters_closure79_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Chain_Once_Logged_IntoIter_Logged_owned_closure10_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: Logged.Logged | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: Logged.Logged | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } + rt.drop(other); + rt.drop(it); +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Chars_iters_closure47_iters_closure48(it: rt.Iter, back: (a0: rt.Iter) => rt.char | undefined, plan: Plan.Plan, put: (a0: rt.char) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.char | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.char | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$ChunksExact_u8_iters_closure26_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.ByteSlice | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.ByteSlice | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Chunks_u8_iters_closure24_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.ByteSlice | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.ByteSlice | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Cloned_Iter_u8_iters_closure76_iters_closure77(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Copied_Iter_u8_iters_closure74_iters_closure75(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Difference_u8_iters_closure129_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Difference_u8_iters_closure130_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Empty_u8_iters_closure45_iters_closure46(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Enumerate_Iter_u8_iters_closure68_iters_closure69(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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.usize, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$FilterMap_Iter_u8_iters_closure65_iters_closure66_iters_closure67(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Filter_Iter_u8_iters_closure141_iters_closure142_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Filter_Iter_u8_iters_closure63_iters_closure64_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Filter_Map_Iter_u8_closures_closure1_closures_closure2_closures_closure3_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } + rt.drop(other); + rt.drop(it); +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$FlatMap_Chunks_u8_Iter_u8_iters_closure81_iters_closure82_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$FlatMap_Chunks_u8_Map_Iter_u8_iters_closure147_closure0_iters_closure147_iters_closure148_iters_closure149(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Flatten_Chunks_u8_iters_closure86_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Flatten_IntoIter_Vec_Logged_owned_closure13_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: Logged.Logged | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: Logged.Logged | undefined = back(it); + if (_32 !== undefined) { + rt.byteVecPush(out, put(_32)); + } + } + const other: rt.Iter = it.clone({ i: { v: (a0: Logged.Logged[]): Logged.Logged[] => { + return a0.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } + rt.drop(other); + rt.drop(it); +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Flatten_Map_Chunks_u8_iters_closure83_iters_closure84_iters_closure85(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$FromFn_iters_closure99_iters_closure100_iters_closure101(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Fuse_Iter_u8_iters_closure78_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Intersection_u8_iters_closure127_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Intersection_u8_iters_closure128_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$IntoIter_Logged_owned_closure2_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: Logged.Logged | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: Logged.Logged | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } + rt.drop(other); + rt.drop(it); +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$IntoIter_Logged_owned_closure5_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: Logged.Logged | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: Logged.Logged | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } + rt.drop(other); + rt.drop(it); +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$IntoIter_u8_iters_closure133_iters_closure134(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$IntoIter_u8_iters_closure136_iters_closure137(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$IntoIter_u8_iters_closure18_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$IntoIter_u8_iters_closure20_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$IntoIter_u8_iters_closure40_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$IntoIter_u8_iters_closure41_iters_closure42(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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_u8_iters_closure124_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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_u8_iters_closure132_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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_u8_iters_closure135_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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_u8_iters_closure17_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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_u8_u8_iters_closure116_iters_closure117(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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.u8, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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_u8s_iters_closure32_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.ByteSlice | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.ByteSlice | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Keys_u8_u8_iters_closure118_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$MapWhile_Iter_u8_iters_closure91_iters_closure92_iters_closure93(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Map_Countdown_iters_closure94_iters_closure95_iters_closure96(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Map_Inspect_Iter_u8_iters_closure143_iters_closure144_iters_closure145_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Map_Iter_u8_iters_closure138_iters_closure139_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Map_Iter_u8_iters_closure60_iters_closure61_iters_closure62(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$MatchIndices_chars_iters_closure58_iters_closure59(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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: [rt.usize, string] | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.usize, string] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Once_u8_iters_closure43_iters_closure44(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Peekable_Copied_Iter_u8_iters_closure114_iters_closure115(it: rt.Peekable, back: (a0: rt.Peekable) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Peekable_IntoIter_Logged_owned_closure8_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: Logged.Logged | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: Logged.Logged | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } + rt.drop(other); + rt.drop(it); +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Peekable_Iter_u8_iters_closure113_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Peekable_Iter_u8_iters_closure80_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$RChunksExact_u8_iters_closure30_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.ByteSlice | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.ByteSlice | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$RChunks_u8_iters_closure28_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.ByteSlice | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.ByteSlice | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$RangeInclusive_u8_iters_closure36_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Range_u64_iters_closure38_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u64 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u64 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Range_u8_iters_closure125_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Range_u8_iters_closure34_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; + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15Some: boolean = it.start < it.end; + if (_15Some) { + _15 = it.start++; + } + if (_15Some) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = other.start < other.end ? other.start++ : undefined; + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = it.start < it.end ? it.start++ : undefined; + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Range_u8_u8_iters_closure120_iters_closure121(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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.u8, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Range_u8_u8_iters_closure122_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.u8, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Rev_Iter_u8_iters_closure70_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$SkipWhile_Iter_u8_iters_closure87_iters_closure88_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Skip_Iter_u8_iters_closure71_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Split_char_iters_closure51_iters_closure52(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: string | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: string | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Split_iters_closure55_iters_closure56_iters_closure57(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: string | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: string | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Split_str_iters_closure53_iters_closure54(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: string | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: string | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$StepBy_Iter_u8_iters_closure73_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Successors_Logged_owned_closure15_owned_closure16_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: Logged.Logged | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: Logged.Logged | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } + rt.drop(other); + rt.drop(it); +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Successors_u8_iters_closure102_iters_closure103_iters_closure104(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$SymmetricDifference_u8_iters_closure131_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$TakeWhile_Iter_u8_iters_closure89_iters_closure90_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Take_Iter_u8_iters_closure72_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Union_u8_iters_closure126_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Values_u8_u8_iters_closure119_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Windows_u8_iters_closure22_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.ByteSlice | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.ByteSlice | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item = back(other); + } else { + item = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item = back(it); + } else { + item = rt.iterToOption(it.next()); + } + if (item === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Zip_Countdown_Iter_u8_iters_closure97_iters_closure98(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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.u8, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Zip_Filter_Iter_u8_iters_closure4_Filter_Iter_u8_iters_closure5_iters_closure107_iters_closure108(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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.u8, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Zip_Iter_u8_Iter_u8_iters_closure105_iters_closure106(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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.u8, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Zip_Iter_u8_Iter_u8_iters_closure109_iters_closure110(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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.u8, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$Zip_Iter_u8_RangeInclusive_u8_iters_closure111_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.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 _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: [rt.u8, rt.u8] | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * 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 _247!: [rt.ByteSlice, rt.ByteSlice]; + let _253!: rt.usize; + let it!: rt.Peekable; + const plan: Plan.Plan = { data, at: kind as rt.usize }; + const n: rt.usize = 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); + if (_9 === 0) { + turns$Iter_u8_iters_closure17_iters_closure0(rt.iterSlice(rt.byteSliceView(data)), (it72: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it72.nextBack()); + }, plan, (x66: rt.u8): rt.u8 => { + return x66; + }, out); + turns$IntoIter_u8_iters_closure18_iters_closure19(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), (it73: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it73.nextBack()); + }, plan, (x67: rt.u8): rt.u8 => { + return x67; + }, 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)), "index"); + while (true) { + const _25: [rt.Place, rt.u8] | rt.Done = iter.next(); + if (_25 === rt.DONE) { + break; + } + _25[0].v = _25[1]; + } + turns$IntoIter_u8_iters_closure20_iters_closure21(rt.iterSlice(array), (it74: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it74.nextBack()); + }, plan, (x68: rt.u8): rt.u8 => { + return x68; + }, out); + } else if (_9 === 1) { + turns$Windows_u8_iters_closure22_iters_closure23(rt.byteSliceWindows(data, n), (it66: rt.Iter): rt.ByteSlice | undefined => { + return rt.iterToOption(it66.nextBack()); + }, plan, (w: rt.ByteSlice): rt.u8 => { + rt.idx(w, 0); + const _326: rt.u8 = w.data[w.start]; + const _810: rt.usize = rt.usizeSub(w.length, 1); + rt.idx(w, _810); + return _326 ^ w.data[w.start + _810]; + }, out); + turns$Chunks_u8_iters_closure24_iters_closure25(rt.byteSliceChunks(data, n), (it67: rt.Iter): rt.ByteSlice | undefined => { + return rt.iterToOption(it67.nextBack()); + }, plan, (c6: rt.ByteSlice): rt.u8 => { + rt.idx(c6, 0); + return c6.data[c6.start] ^ (c6.length & 0xff); + }, out); + turns$ChunksExact_u8_iters_closure26_iters_closure27(rt.byteSliceChunksExact(data, n), (it68: rt.Iter): rt.ByteSlice | undefined => { + return rt.iterToOption(it68.nextBack()); + }, plan, (c7: rt.ByteSlice): rt.u8 => { + rt.idx(c7, 0); + return c7.data[c7.start]; + }, out); + turns$RChunks_u8_iters_closure28_iters_closure29(rt.byteSliceRchunks(data, n), (it69: rt.Iter): rt.ByteSlice | undefined => { + return rt.iterToOption(it69.nextBack()); + }, plan, (c8: rt.ByteSlice): rt.u8 => { + rt.idx(c8, 0); + return c8.data[c8.start] ^ (c8.length & 0xff); + }, out); + turns$RChunksExact_u8_iters_closure30_iters_closure31(rt.byteSliceRchunksExact(data, n), (it70: rt.Iter): rt.ByteSlice | undefined => { + return rt.iterToOption(it70.nextBack()); + }, plan, (c9: rt.ByteSlice): rt.u8 => { + rt.idx(c9, 0); + return c9.data[c9.start]; + }, out); + turns$Iter_u8s_iters_closure32_iters_closure33(rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c10: rt.ByteSlice): Uint8Array => { + rt.idx(c10, 0); + const _330: rt.u8 = c10.data[c10.start]; + rt.idx(c10, 1); + return Uint8Array.of(_330, c10.data[c10.start + 1]); + }), undefined, 2, true)), rt.byteSliceFrom), (it71: rt.Iter): rt.ByteSlice | undefined => { + return rt.iterToOption(it71.nextBack()); + }, plan, (a6: rt.ByteSlice): rt.u8 => { + return a6.data[a6.start] ^ a6.data[a6.start + 1]; + }, out); + } else if (_9 === 2) { + const lo: rt.u8 = rt.u8Rem(unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8); + const hi: rt.u8 = rt.u8Rem(unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 9), 16); + turns$Range_u8_iters_closure34_iters_closure35(new rt.Range(lo, hi), (it59: rt.Range): rt.u8 | undefined => { + return rt.iterToOption(it59.nextBack()); + }, plan, (x59: rt.u8): rt.u8 => { + return x59; + }, out); + turns$RangeInclusive_u8_iters_closure36_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 => { + return x60; + }, out); + turns$Range_u64_iters_closure38_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; + }, out); + turns$IntoIter_u8_iters_closure40_iters_closure0(rt.iterOption(rt.byteSliceFirst(data)), (it62: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it62.nextBack()); + }, plan, (x62: rt.u8): rt.u8 => { + return x62; + }, out); + turns$IntoIter_u8_iters_closure41_iters_closure42(rt.iterOption(rt.byteSliceFirst(data)), (it63: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it63.nextBack()); + }, plan, (x63: rt.u8): rt.u8 => { + return x63; + }, out); + turns$Once_u8_iters_closure43_iters_closure44(rt.iterOnce(n & 0xff), (it64: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it64.nextBack()); + }, plan, (x64: rt.u8): rt.u8 => { + return x64; + }, out); + rt.iterEmpty(); + turns$Empty_u8_iters_closure45_iters_closure46(rt.iterEmpty() as rt.Iter, (it65: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it65.nextBack()); + }, plan, (x65: rt.u8): rt.u8 => { + return x65; + }, out); + } else if (_9 === 3) { + const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_288: rt.u8): rt.char => { + const _518: rt.usize = rt.u8Rem(_288, 4) as rt.usize; + if (!(_518 < 4)) { + rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _518); + } + return [97, 233, 20013, 129408][_518]; + })); + turns$Chars_iters_closure47_iters_closure48(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; + }, out); + turns$Bytes_iters_closure49_iters_closure50(rt.strBytes(text), (it54: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it54.nextBack()); + }, plan, (b15: rt.u8): rt.u8 => { + return b15; + }, out); + turns$Split_char_iters_closure51_iters_closure52(rt.strSplit(text, "é"), (it55: rt.Iter): string | undefined => { + return rt.iterToOption(it55.nextBack()); + }, plan, (s: string): rt.u8 => { + return rt.stringLen(s) & 0xff; + }, out); + turns$Split_str_iters_closure53_iters_closure54(rt.strSplit(text, "中"), (it56: rt.Iter): string | undefined => { + return rt.iterToOption(it56.next()); + }, plan, (s2: string): rt.u8 => { + return rt.stringLen(s2) & 0xff; + }, out); + const _119: string = text; + const make6 = (captured7: rt.u8): (a0: rt.char) => boolean => { + return rt.cloning((c5: rt.char): boolean => { + captured7 = rt.u8WrappingAdd(captured7, 1); + if (!(c5 === 97)) { + return rt.u8Rem(captured7, 3) === 0; + } + return true; + }, () => make6(captured7)); + }; + turns$Split_iters_closure55_iters_closure56_iters_closure57(rt.strSplit(_119, make6(0)), (it57: rt.Iter): string | undefined => { + return rt.iterToOption(it57.nextBack()); + }, plan, (s3: string): rt.u8 => { + return rt.stringLen(s3) & 0xff; + }, out); + turns$MatchIndices_chars_iters_closure58_iters_closure59(rt.strMatchIndices(text, rt.patternChars([97, 129408])), (it58: rt.Iter<[rt.usize, string]>): [rt.usize, string] | undefined => { + return rt.iterToOption(it58.nextBack()); + }, plan, (_290: [rt.usize, string]): rt.u8 => { + return (_290[0] & 0xff) ^ (rt.stringLen(_290[1]) & 0xff); + }, out); + } else if (_9 === 4) { + turns$Map_Iter_u8_iters_closure60_iters_closure61_iters_closure62(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (x49: rt.u8): rt.u8 => { + return x49 ^ 1; + }), (it45: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it45.nextBack()); + }, plan, (x50: rt.u8): rt.u8 => { + return x50; + }, out); + turns$Filter_Iter_u8_iters_closure63_iters_closure64_iters_closure0(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_273: rt.u8): boolean => { + return rt.u8Rem(_273, 3) !== 0; + }), (it46: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it46.nextBack()); + }, plan, (x52: rt.u8): rt.u8 => { + return x52; + }, out); + turns$FilterMap_Iter_u8_iters_closure65_iters_closure66_iters_closure67(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_275: rt.u8): rt.u8 | undefined => { + return rt.u8CheckedSub(_275, 9); + }), (it47: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it47.nextBack()); + }, plan, (x54: rt.u8): rt.u8 => { + return x54; + }, out); + turns$Enumerate_Iter_u8_iters_closure68_iters_closure69(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, (_276: [rt.usize, rt.u8]): rt.u8 => { + return (_276[0] & 0xff) ^ _276[1]; + }, out); + turns$Rev_Iter_u8_iters_closure70_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 => { + return x55; + }, out); + turns$Skip_Iter_u8_iters_closure71_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 => { + return x56; + }, out); + turns$Take_Iter_u8_iters_closure72_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 => { + return x57; + }, out); + turns$StepBy_Iter_u8_iters_closure73_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 => { + return x58; + }, out); + } else if (_9 === 5) { + turns$Copied_Iter_u8_iters_closure74_iters_closure75(rt.iterSlice(rt.byteSliceView(data)), (it37: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it37.nextBack()); + }, plan, (x41: rt.u8): rt.u8 => { + return x41; + }, out); + turns$Cloned_Iter_u8_iters_closure76_iters_closure77(rt.iterCloned(rt.iterSlice(rt.byteSliceView(data))), (it38: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it38.nextBack()); + }, plan, (x42: rt.u8): rt.u8 => { + return x42; + }, out); + turns$Fuse_Iter_u8_iters_closure78_iters_closure0(rt.iterFuse(rt.iterSlice(rt.byteSliceView(data))), (it39: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it39.nextBack()); + }, plan, (x43: rt.u8): rt.u8 => { + return x43; + }, out); + turns$Chain_Iter_u8_Skip_Rev_Iter_u8_iters_closure79_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 => { + return x44; + }, out); + turns$Peekable_Iter_u8_iters_closure80_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 => { + return x45; + }, out); + turns$FlatMap_Chunks_u8_Iter_u8_iters_closure81_iters_closure82_iters_closure0(rt.iterFlatMap(rt.byteSliceChunks(data, n), (c2: rt.ByteSlice): rt.Iter => { + return rt.iterSlice(rt.byteSliceView(c2)); + }), (it42: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it42.nextBack()); + }, plan, (x46: rt.u8): rt.u8 => { + return x46; + }, out); + turns$Flatten_Map_Chunks_u8_iters_closure83_iters_closure84_iters_closure85(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { + return rt.byteSliceToByteVec(c3); + }), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value))), (it43: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it43.nextBack()); + }, plan, (x47: rt.u8): rt.u8 => { + return x47; + }, out); + turns$Flatten_Chunks_u8_iters_closure86_iters_closure0(rt.iterFlatten(rt.byteSliceChunks(data, n), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), (it44: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it44.nextBack()); + }, plan, (x48: rt.u8): rt.u8 => { + return x48; + }, out); + } else if (_9 === 6) { + turns$SkipWhile_Iter_u8_iters_closure87_iters_closure88_iters_closure0(rt.iterSkipWhile(rt.iterSlice(rt.byteSliceView(data)), (_256: rt.u8): boolean => { + return rt.u8Rem(_256, 4) !== 0; + }), (it30: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it30.next()); + }, plan, (x31: rt.u8): rt.u8 => { + return x31; + }, out); + turns$TakeWhile_Iter_u8_iters_closure89_iters_closure90_iters_closure0(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_257: rt.u8): boolean => { + return rt.u8Rem(_257, 5) !== 0; + }), (it31: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it31.next()); + }, plan, (x33: rt.u8): rt.u8 => { + return x33; + }, out); + turns$MapWhile_Iter_u8_iters_closure91_iters_closure92_iters_closure93(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_267: rt.u8): rt.u8 | undefined => { + return rt.u8CheckedSub(_267, 3); + }), (it32: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it32.next()); + }, plan, (x35: rt.u8): rt.u8 => { + return x35; + }, out); + turns$Map_Countdown_iters_closure94_iters_closure95_iters_closure96(rt.iterMap(rt.iterFrom({ _0: rt.u8Mul(n & 0xff, 3) }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (x36: rt.u8): rt.u8 => { + return x36 ^ 7; + }), (it33: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it33.next()); + }, plan, (x37: rt.u8): rt.u8 => { + return x37; + }, out); + const _220: Countdown.Countdown = { _0: rt.u8Mul(n & 0xff, 3) }; + const _224: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + turns$Zip_Countdown_Iter_u8_iters_closure97_iters_closure98(rt.iterZip(rt.iterFrom(_220, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), _224), (it34: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + return rt.iterToOption(it34.next()); + }, plan, (_269: [rt.u8, rt.u8]): rt.u8 => { + return _269[0] ^ _269[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 _270: rt.usize | undefined = rt.usizeCheckedSub(captured6, 1); + if (_270 !== undefined) { + captured6 = _270; + return captured6 & 0xff; + } + return undefined; + }, () => make5(captured6)); + }; + turns$FromFn_iters_closure99_iters_closure100_iters_closure101(rt.iterFromFn(make5(left)), (it35: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it35.next()); + }, plan, (x38: rt.u8): rt.u8 => { + return x38; + }, out); + turns$Successors_u8_iters_closure102_iters_closure103_iters_closure104(rt.iterSuccessors(rt.u8Mul(n & 0xff, 40), (_272: rt.u8): rt.u8 | undefined => { + return rt.u8CheckedSub(_272, 17); + }), (it36: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it36.next()); + }, plan, (x40: rt.u8): rt.u8 => { + return x40; + }, out); + } else if (_9 === 7) { + const mid: number = rt.usizeDiv(data.length, 2); + if (mid > data.length) { + rt.panic("mid > len"); + } + if (!((kind & 32) === 0)) { + _247 = [new rt.ByteSlice(data.data, data.start + mid, data.length - mid), new rt.ByteSlice(data.data, data.start, mid)] as [rt.ByteSlice, rt.ByteSlice]; + } else { + _247 = [new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid, data.length - mid)] as [rt.ByteSlice, rt.ByteSlice]; + } + const a2: rt.ByteSlice = _247[0]; + const b3: rt.ByteSlice = _247[1]; + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = 2; + while ((_253 = iterStart++) < iterEnd) { + const skip: rt.usize = _253; + const zip: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(a2)), rt.iterSlice(rt.byteSliceView(b3)), "index"); + const _262: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), skip); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = _262; + while (iterStart2++ < iterEnd2) { + zip.next(); + } + turns$Zip_Iter_u8_Iter_u8_iters_closure105_iters_closure106(zip, (it26: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + return rt.iterToOption(it26.nextBack()); + }, plan, (_242: [rt.u8, rt.u8]): rt.u8 => { + return _242[0] ^ _242[1]; + }, out); + const zip2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFilter(rt.iterSlice(rt.byteSliceView(a2)), (_243: rt.u8): boolean => { + return true; + }), rt.iterFilter(rt.iterSlice(rt.byteSliceView(b3)), (_245: rt.u8): boolean => { + return true; + })); + const _283: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), skip); + let iterStart3: rt.usize = 0; + const iterEnd3: rt.usize = _283; + while (iterStart3++ < iterEnd3) { + zip2.next(); + } + turns$Zip_Filter_Iter_u8_iters_closure4_Filter_Iter_u8_iters_closure5_iters_closure107_iters_closure108(zip2, (it27: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + return rt.iterToOption(it27.next()); + }, plan, (_246: [rt.u8, rt.u8]): rt.u8 => { + return _246[0] ^ _246[1]; + }, out); + } + turns$Zip_Iter_u8_Iter_u8_iters_closure109_iters_closure110(rt.iterZip(rt.iterSlice(rt.byteSliceView(a2)), rt.iterSlice(rt.byteSliceView(b3)), "index"), (it28: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + return rt.iterToOption(it28.nextBack()); + }, plan, (_252: [rt.u8, rt.u8]): rt.u8 => { + return _252[0] ^ _252[1]; + }, out); + turns$Zip_Iter_u8_RangeInclusive_u8_iters_closure111_iters_closure112(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, (_254: [rt.u8, rt.u8]): rt.u8 => { + return _254[0] ^ _254[1]; + }, out); + const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); + const zip3: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_255: rt.u8): rt.u8 => { + const x28: rt.u8 = _255; + const _610: rt.RefCell = rt.refCellBorrowMut(log); + rt.byteVecPush(_610.value, x28); + rt.refMutRelease(_610); + return x28; + }); + const _314: rt.Iter = zip3; + const _316: rt.Iter = rt.iterSlice(rt.byteSliceView(b3)); + const zip22: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterBorrow(_314), _316, "len"); + const _319: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), 1); + let iterStart4: rt.usize = 0; + const iterEnd4: rt.usize = _319; + while (iterStart4++ < iterEnd4) { + zip22.next(); + } + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(zip3.clone(), zip3), (x29: rt.u8): rt.u8 => { + return x29 ^ 64; + }), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + } else if (_9 === 8) { + it = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); + let iterStart5: rt.usize = 0; + const iterEnd5: rt.usize = n; + while (iterStart5++ < iterEnd5) { + rt.byteVecPush(out, mapOr$1surhce(rt.peekablePeek(it), 238, (_238: rt.u8): rt.u8 => { + return _238; + })); + it.next(); + } + rt.byteVecPush(out, mapOr$1surhce(rt.peekablePeek(it), 238, (_239: rt.u8): rt.u8 => { + return _239; + })); + turns$Peekable_Iter_u8_iters_closure113_iters_closure0(it, (it24: rt.Peekable): rt.u8 | undefined => { + return rt.iterToOption(it24.nextBack()); + }, plan, (x26: rt.u8): rt.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$Peekable_Copied_Iter_u8_iters_closure114_iters_closure115(it2, (it25: rt.Peekable): rt.u8 | undefined => { + return rt.iterToOption(it25.nextBack()); + }, plan, (x27: rt.u8): rt.u8 => { + return x27; + }, out); + } else if (_9 === 9) { + const _387: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_225: rt.u8): [rt.u8, rt.u8] => { + const b12: rt.u8 = _225; + return [rt.u8Rem(b12, 32), b12] as [rt.u8, rt.u8]; + }); + const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _387, true, undefined, undefined, undefined, 2, true); + const _390: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): rt.u8 => { + return rt.u8Rem(_226, 32); + }); + const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _390, true, undefined, undefined, 1, true); + const lo2: rt.u8 = rt.u8Rem(unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 32); + turns$Iter_u8_u8_iters_closure116_iters_closure117(rt.btreeIter(map), (it17: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + return rt.iterToOption(it17.nextBack()); + }, plan, (_228: [rt.u8, rt.u8]): rt.u8 => { + return _228[0] ^ _228[1]; + }, out); + turns$Keys_u8_u8_iters_closure118_iters_closure0(rt.btreeKeys(map), (it18: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it18.nextBack()); + }, plan, (x20: rt.u8): rt.u8 => { + return x20; + }, out); + turns$Values_u8_u8_iters_closure119_iters_closure0(rt.btreeValues(map), (it19: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it19.nextBack()); + }, plan, (x21: rt.u8): rt.u8 => { + return x21; + }, out); + turns$Range_u8_u8_iters_closure120_iters_closure121(rt.btreeRange(map, { start: lo2 }), (it20: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + return rt.iterToOption(it20.nextBack()); + }, plan, (_231: [rt.u8, rt.u8]): rt.u8 => { + return _231[0] ^ _231[1]; + }, out); + turns$Range_u8_u8_iters_closure122_iters_closure123(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, (_232: [rt.u8, rt.u8]): rt.u8 => { + return _232[0] ^ _232[1]; + }, out); + turns$Iter_u8_iters_closure124_iters_closure0(rt.btreeKeys(set), (it22: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it22.nextBack()); + }, plan, (x22: rt.u8): rt.u8 => { + return x22; + }, out); + turns$Range_u8_iters_closure125_iters_closure0(rt.btreeRangeKeys(set, { start: lo2 }), (it23: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it23.nextBack()); + }, plan, (x23: rt.u8): rt.u8 => { + return x23; + }, out); + } else if (_9 === 10) { + const _429: 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 map2: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _429, undefined, undefined, undefined, 469762048); + const _432: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_217: rt.u8): rt.u8 => { + return rt.u8Rem(_217, 32); + }); + const set2: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _432, undefined, undefined, 469762048); + unordered$Map_Iter_u8_u8_iters_closure14(rt.iterMap(rt.hashIter(map2), (_218: [rt.u8, rt.u8]): rt.u8 => { + return _218[0] ^ _218[1]; + }), plan, out); + unordered$Copied_Keys_u8_u8(rt.hashKeys(map2), plan, out); + unordered$Copied_Values_u8_u8(rt.hashValues(map2), plan, out); + unordered$Copied_Iter_u8(rt.hashKeys(set2), plan, out); + } else if (_9 === 11) { + const split2: rt.usize = rt.usizeRem(unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, rt.usizeAdd(data.length, 1)); + const _464: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, split2))), (_29: rt.u8): rt.u8 => { + return rt.u8Rem(_29, 64); + }); + const a3: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _464, true, undefined, undefined, 1, true); + const _469: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, split2))), (_210: rt.u8): rt.u8 => { + return rt.u8Rem(_210, 64); + }); + const b4: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _469, true, undefined, undefined, 1, true); + turns$Union_u8_iters_closure126_iters_closure0(rt.btreeUnion(a3, b4), (it11: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it11.next()); + }, plan, (x14: rt.u8): rt.u8 => { + return x14; + }, out); + turns$Intersection_u8_iters_closure127_iters_closure0(rt.btreeIntersection(a3, b4), (it12: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it12.next()); + }, plan, (x15: rt.u8): rt.u8 => { + return x15; + }, out); + turns$Intersection_u8_iters_closure128_iters_closure0(rt.btreeIntersection(b4, a3), (it13: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it13.next()); + }, plan, (x16: rt.u8): rt.u8 => { + return x16; + }, out); + turns$Difference_u8_iters_closure129_iters_closure0(rt.btreeDifference(a3, b4), (it14: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it14.next()); + }, plan, (x17: rt.u8): rt.u8 => { + return x17; + }, out); + turns$Difference_u8_iters_closure130_iters_closure0(rt.btreeDifference(b4, a3), (it15: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it15.next()); + }, plan, (x18: rt.u8): rt.u8 => { + return x18; + }, out); + turns$SymmetricDifference_u8_iters_closure131_iters_closure0(rt.btreeSymmetricDifference(a3, b4), (it16: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it16.next()); + }, plan, (x19: rt.u8): rt.u8 => { + return x19; + }, out); + const _504: rt.Iter = rt.btreeKeys(a3); + const a4: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _504, undefined, undefined, 469762048); + const _506: rt.Iter = rt.btreeKeys(b4); + const b5: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _506, undefined, undefined, 469762048); + unordered$Copied_Union_u8_RandomState(rt.hashUnion(a4, b5), plan, out); + unordered$Copied_Intersection_u8_RandomState(rt.hashIntersection(a4, b5), plan, out); + unordered$Copied_Difference_u8_RandomState(rt.hashDifference(a4, b5), plan, out); + unordered$Copied_SymmetricDifference_u8_RandomState(rt.hashSymmetricDifference(a4, b5), plan, out); + } else if (_9 === 12) { + const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + for (const b6 of rt.byteSliceView(data)) { + if (rt.u8Rem(b6, 2) === 0) { + rt.dequePushFront(q, b6); + } else { + rt.dequePushBack(q, b6); + } + } + turns$Iter_u8_iters_closure132_iters_closure0(rt.dequeIter(q), (it7: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it7.nextBack()); + }, plan, (x10: rt.u8): rt.u8 => { + return x10; + }, out); + turns$IntoIter_u8_iters_closure133_iters_closure134(rt.dequeIter(rt.dequeClone(q, undefined)), (it8: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it8.nextBack()); + }, plan, (x11: rt.u8): rt.u8 => { + return x11; + }, out); + const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); + turns$Iter_u8_iters_closure135_iters_closure0(rt.heapIter(heap), (it9: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it9.nextBack()); + }, plan, (x12: rt.u8): rt.u8 => { + return x12; + }, out); + turns$IntoIter_u8_iters_closure136_iters_closure137(rt.heapIter(heap), (it10: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it10.nextBack()); + }, plan, (x13: rt.u8): rt.u8 => { + return x13; + }, out); + } else if (_9 === 13) { + owned(data, plan, out); + } else if (_9 === 14) { + closures(data, plan, out); + } else { + const _566: 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); + return x ^ captured; + }, () => make(captured)); + }; + turns$Map_Iter_u8_iters_closure138_iters_closure139_iters_closure140(rt.iterMap(_566, make(0)), (it3: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it3.nextBack()); + }, plan, (x2: rt.u8): rt.u8 => { + return x2; + }, out); + const seen: rt.ByteVec = new rt.ByteVec(); + const _572: 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)); + })(captured2))); + }; + turns$Filter_Iter_u8_iters_closure141_iters_closure142_iters_closure0(rt.iterFilter(_572, make2(seen)), (it4: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it4.nextBack()); + }, plan, (x4: rt.u8): rt.u8 => { + return x4; + }, out); + const _578: 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); + }, () => make3(captured3)); + }; + turns$Map_Inspect_Iter_u8_iters_closure143_iters_closure144_iters_closure145_iters_closure146(rt.iterMap(rt.iterInspect(_578, make3(0)), (_28: rt.u8): rt.u8 => { + return _28; + }), (it5: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it5.next()); + }, plan, (x7: rt.u8): rt.u8 => { + return x7; + }, out); + const _583: 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 captured5 = captured4; + return rt.iterMap(_45, (x8: rt.u8): rt.u8 => { + return x8 ^ captured5; + }); + }, () => make4(captured4)); + }; + turns$FlatMap_Chunks_u8_Map_Iter_u8_iters_closure147_closure0_iters_closure147_iters_closure148_iters_closure149(rt.iterFlatMap(_583, make4(0)), (it6: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it6.nextBack()); + }, plan, (x9: rt.u8): rt.u8 => { + return x9; + }, out); + } +} + +/** + * `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$Copied_Difference_u8_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()); + }), "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.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.byteSliceView(rt.byteVecSlice(all)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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$Copied_Intersection_u8_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()); + }), "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.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.byteSliceView(rt.byteVecSlice(all)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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$Copied_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()); + }), "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.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.byteSliceView(rt.byteVecSlice(all)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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$Copied_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()); + }), "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.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.byteSliceView(rt.byteVecSlice(all)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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$Copied_SymmetricDifference_u8_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()); + }), "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.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.byteSliceView(rt.byteVecSlice(all)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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$Copied_Union_u8_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()); + }), "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.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.byteSliceView(rt.byteVecSlice(all)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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$Copied_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()); + }), "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.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.byteSliceView(rt.byteVecSlice(all)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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$Map_Iter_u8_u8_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()); + }), "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.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.byteSliceView(rt.byteVecSlice(all)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(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)); + }; + const it: rt.Iter = rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6), (_2: rt.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 }); + flush(log.value, out); + rt.drop(it); + flush(log.value, out); + turns$IntoIter_Logged_owned_closure2_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); + x[Symbol.dispose](); + return _04; + }, out); + flush(log.value, out); + const _35: rt.Iter = rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_22: rt.u8): Logged.Logged => { + return logged(_22 & 112); + }); + turns$IntoIter_Logged_owned_closure5_owned_closure6(rt.dequeIter(rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_35, undefined, 8, true))), 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); + x2[Symbol.dispose](); + return _07; + }, out); + flush(log.value, out); + const it2: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_24: rt.u8): Logged.Logged => { + return logged(_24 & 112); + }), undefined, 8, true), rt.drop), rt.drop); + rt.byteVecPush(out, mapOr$1yabfom(rt.peekablePeek(it2), 238, Logged.id)); + const clone2: rt.Peekable = it2.clone({ i: { v: Logged.clone$Clone }, v: Logged.clone$Clone }); + flush(log.value, out); + rt.drop(clone2); + flush(log.value, out); + turns$Peekable_IntoIter_Logged_owned_closure8_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); + 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 } }); + flush(log.value, out); + rt.drop(it3); + turns$Chain_Once_Logged_IntoIter_Logged_owned_closure10_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); + x4[Symbol.dispose](); + return _012; + }, out); + flush(log.value, out); + const it4: rt.Iter = rt.iterFlatten(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterTake(rt.byteSliceChunks(data, 3), 3), (c: rt.ByteSlice): Logged.Logged[] => { + return rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(c)), (_25: rt.u8): Logged.Logged => { + return logged(_25 & 112); + }), undefined, 8, true); + }), undefined, 12, true), drop$Vec_Logged), (value: Logged.Logged[]) => rt.iterSlice(value, rt.drop), true); + rt.drop(rt.iterToOption(it4.next())); + rt.drop(rt.iterToOption(it4.nextBack())); + const clone4: rt.Iter = it4.clone({ i: { v: (a07: Logged.Logged[]): Logged.Logged[] => { + return a07.map(Logged.clone$Clone); + } }, o: { v: Logged.clone$Clone } }); + flush(log.value, out); + rt.drop(it4); + flush(log.value, out); + turns$Flatten_IntoIter_Vec_Logged_owned_closure13_owned_closure14(clone4, (it10: rt.Iter): Logged.Logged | undefined => { + return rt.iterToOption(it10.nextBack()); + }, plan, (x5: Logged.Logged): rt.u8 => { + const _016: rt.u8 = Logged.id(x5); + x5[Symbol.dispose](); + return _016; + }, out); + flush(log.value, out); + const it5: rt.Iter = rt.iterSuccessors(logged(40), (x6: Logged.Logged): Logged.Logged | undefined => { + return map$0y3liwu(rt.u8CheckedSub(Logged.id(x6), 13), (id2: rt.u8): Logged.Logged => { + return logged(id2); + }); + }, rt.drop); + rt.drop(rt.iterToOption(it5.next())); + const clone5: rt.Iter = it5.clone({ v: Logged.clone$Clone }); + flush(log.value, out); + turns$Successors_Logged_owned_closure15_owned_closure16_owned_closure17(clone5, (it11: rt.Iter): Logged.Logged | undefined => { + return rt.iterToOption(it11.next()); + }, plan, (x7: Logged.Logged): rt.u8 => { + const _020: rt.u8 = Logged.id(x7); + x7[Symbol.dispose](); + return _020; + }, out); + rt.drop(it5); + flush(log.value, out); + log[Symbol.dispose](); +} + +/** + * 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)); + }; + 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 => { + 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 => { + 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 }); + flush(log.value, out); + rt.drop(it); + flush(log.value, out); + turns$Filter_Map_Iter_u8_closures_closure1_closures_closure2_closures_closure3_closures_closure4(clone, (it4: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it4.nextBack()); + }, plan, (x3: rt.u8): rt.u8 => { + return x3; + }, out); + flush(log.value, out); + const _38: [Logged.Logged, rt.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)); + return x4 ^ captured3; + }, () => make3(captured3, Logged.clone$Clone(captured4))), (): void => { + captured4[Symbol.dispose](); + }); + }; + const it2: rt.Iter = rt.iterMap(_43, make3(count, tag)); + it2.next(); + const clone2: rt.Iter = it2.clone({ f: rt.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); + flush(log.value, out); + rt.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)); + 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 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 => { + return captured7(x6) ^ Logged.id(captured8); + }, () => make5(rt.closureClone(captured7), Logged.clone$Clone(captured8))), (): void => { + rt.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); + flush(log.value, out); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(outer(2), copy(3), copy(4), outer(5))), undefined, true); + rt.drop(outer); + flush(log.value, out); + rt.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] => { + captured9 = captured9 + "c"; + return [captured9, captured10] as [string, Logged.Logged]; + }, () => make6(captured9, Logged.clone$Clone(captured10))), (): void => { + captured10[Symbol.dispose](); + }); + }; + const once: () => [string, Logged.Logged] = make6(text, tag2); + const twice: () => [string, Logged.Logged] = rt.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); + 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); + 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 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 => { + return _25[0] ^ _25[1]; + }), undefined, true); + log[Symbol.dispose](); +} + +//# sourceMappingURL=clones.ts.map diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index ea949c049..16a11ed14 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -3,6 +3,7 @@ import * as rt from "../rt.ts"; import type * as Noisy from "../borrows.Noisy.ts"; import type * as Item from "../bounds.Item.ts"; +import * as Logged from "../clones.Logged.ts"; import type * as Nibble from "../collections.Nibble.ts"; import type * as Picky from "../collections.Picky.ts"; import type * as Rank from "../collections.Rank.ts"; @@ -413,6 +414,13 @@ export function map$0a57co2(self: rt.u32 | undefined, f: (a0: rt.u32) => rt.u8): return f(self); } +export function map$0y3liwu(self: rt.u8 | undefined, f: (a0: rt.u8) => Logged.Logged): Logged.Logged | 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 { if (self === undefined) { return rt.None; @@ -596,6 +604,13 @@ export function mapOr$14aggam(self: orders_Item.Item | undefined, default_: rt.u return f(self); } +export function mapOr$1yabfom(self: Logged.Logged | undefined, default_: rt.u8, _: (a0: Logged.Logged) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return Logged.id(self); +} + export function mapOr$1ybqvup(self: Meters.Meters | undefined, default_: rt.u64, f: (a0: Meters.Meters) => rt.u64): rt.u64 { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index cc619a699..497e7403b 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -9,6 +9,7 @@ import { captures } from "./captures.ts"; import { cells } from "./cells.ts"; import { chars } from "./chars.ts"; import { chunks } from "./chunks.ts"; +import { iters } from "./clones.ts"; import { hashMaps, sets, btreeMaps, deques, vecs, stores, optionals, setOps, unlikeEqs, ownNes } from "./collections.ts"; import { combinators } from "./combinators.ts"; import { arcs, clonedArcs, cyclicArcs, uniqueArcs, clonedRcs, cyclicRcs, rcs, uniqueRcs, copies } from "./counts.ts"; @@ -19,7 +20,7 @@ import { dyns, shared, anys, fns } from "./dyns.ts"; import { edits, bytes } from "./edits.ts"; import { eqs } from "./errors.ts"; import { floats, mulAdds, formats, parses } from "./floats.ts"; -import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, iters, writes } from "./fmt.ts"; +import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, iters as fmt_iters, writes } from "./fmt.ts"; import { folds } from "./folds.ts"; import { methods } from "./generics.ts"; import { values, random, bytes as hashes_bytes } from "./hashes.ts"; @@ -195,8 +196,8 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] 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], ["singles::mul_adds", singles_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { collections(data71, out72); }] 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], ["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", zeros_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::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], ["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], ["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], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { - iters(data72, out73); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + fmt_iters(data72, out73); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["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]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 38727d25e..e6ec71c19 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -1153,7 +1153,7 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { 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 = rt.rangeClone(range); + const copy: rt.Range = range.clone(); rt.byteVecPush(out, 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); @@ -1244,8 +1244,8 @@ export function updates(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec) rt.byteVecPush(out, 208); const _7: rt.u8 = rt.u8Div(b, 2); rt.byteVecPush(out, 209); - const made: rt.Range = new rt.Range(rt.rangeClone(base).start, _7); - const _14: rt.Range = rt.rangeClone(base); + 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); @@ -1265,7 +1265,7 @@ export function updates(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec) rt.byteVecPush(out, 210); rt.byteVecPush(out, 211); rt.byteVecPush(out, 212); - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(data, from, rt.rangeClone(all).end)); + 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); diff --git a/ts/fixtures/lang/expected/lib.ts b/ts/fixtures/lang/expected/lib.ts index 1f52b43ed..0c74e95b8 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import type * as Logged from "./clones.Logged.ts"; import type * as Picky from "./collections.Picky.ts"; import type * as Tally from "./collections.Tally.ts"; import type * as Any from "./core/any.Any.ts"; @@ -441,6 +442,10 @@ export function drop$Vec_Arc_Noisy_Vec_Arc_Noisy_Vec_ArcShared_Vec_Noisy_Vec_Vec rt.dropAll(_1[4], drop$Vec_Arc_Noisy); } +export function drop$Vec_Logged(value: Logged.Logged[]): void { + rt.dropAll(value); +} + export function drop$Vec_Rc_Noisy(value: rt.Arc[]): void { rt.dropAll(value); } diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index 90ffdebf0..1a8840157 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -1547,7 +1547,7 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { 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; - const bounds6 = rt.sliceGetBounds(rt.rangeInclusiveClone(stepped), _289.length); + const bounds6 = rt.sliceGetBounds(stepped.clone(), _289.length); const _288: rt.u16[] | undefined = rt.sliceGetRange(_289, bounds6[0], bounds6[1]); if (_288 === undefined) { _287 = 238; @@ -1556,7 +1556,7 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _287); const _298: rt.ByteSlice = rt.byteVecSlice(bytes); - const bounds7 = rt.sliceGetBounds(rt.rangeInclusiveClone(folded), _298.length); + const bounds7 = rt.sliceGetBounds(folded.clone(), _298.length); const _297: rt.ByteSlice | undefined = rt.byteSliceGetRange(_298, bounds7[0], bounds7[1]); if (_297 === undefined) { _296 = 238; @@ -1565,7 +1565,7 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _296); const _307: Pair.Pair[] = pairs; - const bounds8 = rt.sliceGetBounds(rt.rangeInclusiveClone(folded), _307.length); + const bounds8 = rt.sliceGetBounds(folded.clone(), _307.length); const _306: Pair.Pair[] | undefined = rt.sliceGetRangeMut(_307, bounds8[0], bounds8[1]); if (_306 === undefined) { _305 = 238; @@ -1575,7 +1575,7 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })(_306); } rt.byteVecPush(out, _305); - const bounds9 = rt.sliceIndexBounds(rt.rangeInclusiveClone(folded), words.length); + const bounds9 = rt.sliceIndexBounds(folded.clone(), words.length); pokeWords(7, rt.sliceRangeMut(words, bounds9[0], bounds9[1])); const _324: rt.RangeInclusive = stepped; const slice3 = rt.byteVecSlice(bytes); diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 21263426e..16701074b 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -297,7 +297,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, rt.iterAll(rejected, (x4: rt.u64): boolean => { return rt.u64Lt(x4, hi); }) ? 1 : 0); - bounds$RangeInclusive_u64(out, rt.rangeInclusiveClone(rejected)); + bounds$RangeInclusive_u64(out, rejected.clone()); rt.byteVecPush(out, rt.iterFind(rejected, (_27: rt.u64): boolean => { return true; }) !== undefined ? 1 : 0); diff --git a/ts/fixtures/lang/src/clones.rs b/ts/fixtures/lang/src/clones.rs new file mode 100644 index 000000000..3dec52d0d --- /dev/null +++ b/ts/fixtures/lang/src/clones.rs @@ -0,0 +1,530 @@ +//! Clones of std's iterators and adaptors, and of closures: each read on from where the +//! original was, independently of it, the two read in turns from either end after partial +//! reads, with what they own cloned and dropped as std's do. + +use std::cell::RefCell; +use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque}; +use std::rc::Rc; + +/// 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. +struct Logged { + id: u8, + log: Rc>>, +} + +impl Logged { + fn id(&self) -> u8 { + self.id + } +} + +impl Clone for Logged { + fn clone(&self) -> Self { + self.log.borrow_mut().push(0x80 | self.id); + Self { + id: self.id.wrapping_add(1), + log: self.log.clone(), + } + } +} + +impl Drop for Logged { + fn drop(&mut self) { + self.log.borrow_mut().push(self.id); + } +} + +/// Puts what was logged since the last flush, after a marker. +fn flush(log: &RefCell>, out: &mut Vec) { + out.push(0xfd); + out.extend(log.borrow_mut().drain(..)); +} + +/// The crate's own iterator, which std's adaptors hold by value. +#[derive(Clone)] +struct Countdown(u8); + +impl Iterator for Countdown { + type Item = u8; + + fn next(&mut self) -> Option { + self.0 = self.0.checked_sub(1)?; + Some(self.0) + } +} + +/// What `turns` reads by: the case's bytes, each step's taken in order. +struct Plan<'a> { + data: &'a [u8], + at: usize, +} + +impl Plan<'_> { + fn next(&mut self) -> u8 { + let b = self.data.get(self.at % self.data.len().max(1)).copied().unwrap_or(0); + self.at += 1; + b ^ (self.at as u8).wrapping_mul(29) + } +} + +/// `it` read up to three times from the front and then from the back by `back`, cloned, and +/// 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. +fn turns( + mut it: I, + back: impl Fn(&mut I) -> Option, + plan: &mut Plan<'_>, + put: impl Fn(I::Item) -> u8, + out: &mut Vec, +) { + for _ in 0..plan.next() % 4 { + if let Some(item) = it.next() { + out.push(put(item)); + } + } + for _ in 0..plan.next() % 4 { + if let Some(item) = back(&mut it) { + out.push(put(item)); + } + } + let mut other = it.clone(); + let hint = |it: &I| { + let (lower, upper) = it.size_hint(); + [lower as u8, upper.map_or(0xfe, |n| n as u8)] + }; + out.extend(hint(&it)); + out.extend(hint(&other)); + let (mut ended, mut other_ended) = (false, false); + // Bounded, for an iterator that never ends. + for _ in 0..64 { + if ended && other_ended { + break; + } + let step = plan.next(); + let first = step & 1 == 0 && !ended || other_ended; + let item = match (first, step & 2 == 0) { + (true, true) => it.next(), + (true, false) => back(&mut it), + (false, true) => other.next(), + (false, false) => back(&mut other), + }; + match item { + Some(item) => out.push(put(item)), + None => { + match first { + true => ended = true, + false => other_ended = true, + } + out.extend([0xff, first as u8]); + } + } + } +} + +/// Each of std's iterators and adaptors, partly read and cloned, read in turns with its +/// clone. +pub fn iters(kind: u8, data: &[u8], out: &mut Vec) { + let mut plan = Plan { + data, + at: usize::from(kind), + }; + macro_rules! both { + ($it:expr, $put:expr) => { + turns( + $it, + |it: &mut _| DoubleEndedIterator::next_back(it), + &mut plan, + $put, + out, + ) + }; + } + macro_rules! front { + ($it:expr, $put:expr) => { + turns($it, |it: &mut _| Iterator::next(it), &mut plan, $put, out) + }; + } + let id = |x: &u8| *x; + let n = usize::from(data.first().map_or(1, |&b| b % 4 + 1)); + match kind % 16 { + 0 => { + both!(data.iter(), id); + both!(data.to_vec().into_iter(), |x| x); + let mut array = [1u8, 2, 3, 4]; + for (a, &b) in array.iter_mut().zip(data) { + *a = b; + } + both!(array.into_iter(), |x| x); + } + 1 => { + both!(data.windows(n), |w| w[0] ^ w[w.len() - 1]); + both!(data.chunks(n), |c| c[0] ^ c.len() as u8); + both!(data.chunks_exact(n), |c| c[0]); + both!(data.rchunks(n), |c| c[0] ^ c.len() as u8); + both!(data.rchunks_exact(n), |c| c[0]); + // Arrays of bytes, which a borrow lends as slices of them. + let arrays: Vec<[u8; 2]> = data.chunks_exact(2).map(|c| [c[0], c[1]]).collect(); + both!(arrays.iter(), |a| a[0] ^ a[1]); + } + 2 => { + let lo = data.first().copied().unwrap_or(0) % 8; + let hi = data.get(1).copied().unwrap_or(9) % 16; + both!(lo..hi, |x| x); + both!(lo..=hi, |x| x); + both!(u64::from(lo)..u64::from(hi), |x| x as u8); + both!(data.first().into_iter(), id); + both!(data.first().copied().into_iter(), |x| x); + both!(std::iter::once(n as u8), |x| x); + both!(std::iter::empty::(), |x| x); + } + // Text of one-, two-, three-, and four-byte chars, read mid-text. + 3 => { + let text: String = data + .iter() + .map(|&b| ['a', 'é', '中', '🦀'][usize::from(b % 4)]) + .collect(); + both!(text.chars(), |c| (c as u32 % 251) as u8); + both!(text.bytes(), |b| b); + both!(text.split('é'), |s| s.len() as u8); + front!(text.split("中"), |s| s.len() as u8); + let mut seen = 0u8; + both!( + text.split(move |c: char| { + seen = seen.wrapping_add(1); + c == 'a' || seen % 3 == 0 + }), + |s| s.len() as u8 + ); + both!(text.match_indices(['a', '🦀']), |(i, s)| i as u8 ^ s.len() as u8); + } + // Adaptors, from either end. + 4 => { + both!(data.iter().map(|x| x ^ 1), |x| x); + both!(data.iter().filter(|&&x| x % 3 != 0), id); + both!(data.iter().filter_map(|&x| x.checked_sub(9)), |x| x); + both!(data.iter().enumerate(), |(i, x)| i as u8 ^ x); + both!(data.iter().rev(), id); + both!(data.iter().skip(n), id); + both!(data.iter().take(n * 2), id); + both!(data.iter().step_by(n), id); + } + 5 => { + both!(data.iter().copied(), |x| x); + both!(data.iter().cloned(), |x| x); + both!(data.iter().fuse(), id); + both!(data.iter().chain(data.iter().rev().skip(1)), id); + both!(data.iter().peekable(), id); + both!(data.chunks(n).flat_map(|c| c.iter()), id); + both!(data.chunks(n).map(|c| c.to_vec()).flatten(), |x| x); + both!(data.chunks(n).flatten(), id); + } + // Adaptors read only from the front. + 6 => { + front!(data.iter().skip_while(|&&x| x % 4 != 0), id); + front!(data.iter().take_while(|&&x| x % 5 != 0), id); + front!(data.iter().map_while(|&x| x.checked_sub(3)), |x| x); + front!(Countdown(n as u8 * 3).map(|x| x ^ 7), |x| x); + front!(Countdown(n as u8 * 3).zip(data.iter()), |(a, b)| a ^ b); + let mut left = n * 3; + front!( + std::iter::from_fn(move || { + left = left.checked_sub(1)?; + Some(left as u8) + }), + |x| x + ); + front!(std::iter::successors(Some(n as u8 * 40), |&x| x.checked_sub(17)), |x| x); + } + // A zip, read past its shorter side before the clone, of iterators by index and not. + 7 => { + let split = data.len() / 2; + let (a, b) = data.split_at(split); + let (a, b) = if kind & 32 == 0 { (a, b) } else { (b, a) }; + for skip in 0..2 { + let mut zip = a.iter().zip(b.iter()); + for _ in 0..a.len().min(b.len()) + skip { + zip.next(); + } + both!(zip, |(x, y)| x ^ y); + let mut zip = a.iter().filter(|_| true).zip(b.iter().filter(|_| true)); + for _ in 0..a.len().min(b.len()) + skip { + zip.next(); + } + front!(zip, |(x, y)| x ^ y); + } + both!(a.iter().zip(b.iter()), |(x, y)| x ^ y); + front!(a.iter().zip(1..=7u8), |(x, y)| x ^ y); + let log = RefCell::new(Vec::new()); + let mut zip = a.iter().map(|&x| { + log.borrow_mut().push(x); + x + }); + let mut zip2 = zip.by_ref().zip(b.iter()); + for _ in 0..a.len().min(b.len()) + 1 { + zip2.next(); + } + drop(zip2); + let clone = zip.clone(); + out.extend(clone.chain(zip).map(|x| x ^ 0x40)); + out.extend(log.take()); + } + // A peeked item, and a peeked end. + 8 => { + let mut it = data.iter().peekable(); + for _ in 0..n { + out.push(it.peek().map_or(0xee, |&&x| x)); + it.next(); + } + out.push(it.peek().map_or(0xee, |&&x| x)); + both!(it, id); + let mut it = data.iter().copied().peekable(); + while it.next().is_some() {} + out.push(it.peek().is_some() as u8); + let mut clone = it.clone(); + out.push(clone.peek().is_some() as u8); + both!(it, |x| x); + } + // B-tree iterators. + 9 => { + let map: BTreeMap = data.iter().map(|&b| (b % 32, b)).collect(); + let set: BTreeSet = data.iter().map(|&b| b % 32).collect(); + let lo = data.first().copied().unwrap_or(0) % 32; + both!(map.iter(), |(k, v)| k ^ v); + both!(map.keys(), id); + both!(map.values(), id); + both!(map.range(lo..), |(k, v)| k ^ v); + both!(map.range(..=lo), |(k, v)| k ^ v); + both!(set.iter(), id); + both!(set.range(lo..), id); + } + // Hash iterators, whose order std leaves unspecified: each read the same as its clone. + 10 => { + let map: HashMap = data.iter().map(|&b| (b % 32, b)).collect(); + let set: HashSet = data.iter().map(|&b| b % 32).collect(); + unordered(map.iter().map(|(k, v)| k ^ v), &mut plan, out); + unordered(map.keys().copied(), &mut plan, out); + unordered(map.values().copied(), &mut plan, out); + unordered(set.iter().copied(), &mut plan, out); + } + // Set operations, of sets small and large enough to look up rather than merge. + 11 => { + let split = usize::from(data.first().copied().unwrap_or(0)) % (data.len() + 1); + let a: BTreeSet = data[..split].iter().map(|&b| b % 64).collect(); + let b: BTreeSet = data[split..].iter().map(|&b| b % 64).collect(); + front!(a.union(&b), id); + front!(a.intersection(&b), id); + front!(b.intersection(&a), id); + front!(a.difference(&b), id); + front!(b.difference(&a), id); + front!(a.symmetric_difference(&b), id); + let a: HashSet = a.into_iter().collect(); + let b: HashSet = b.into_iter().collect(); + unordered(a.union(&b).copied(), &mut plan, out); + unordered(a.intersection(&b).copied(), &mut plan, out); + unordered(a.difference(&b).copied(), &mut plan, out); + unordered(a.symmetric_difference(&b).copied(), &mut plan, out); + } + // Deques and heaps, borrowed and owned. + 12 => { + // Split across the end of its buffer. + let mut q = VecDeque::new(); + for &b in data { + match b % 2 { + 0 => q.push_front(b), + _ => q.push_back(b), + } + } + both!(q.iter(), id); + both!(q.clone().into_iter(), |x| x); + let heap: BinaryHeap = data.iter().copied().collect(); + both!(heap.iter(), id); + both!(heap.into_iter(), |x| x); + } + 13 => owned(data, &mut plan, out), + 14 => closures(data, &mut plan, out), + // Adaptors whose closures write their captures, so each clone counts on its own. + _ => { + let mut count = 0u8; + both!( + data.iter().map(move |&x| { + count = count.wrapping_add(1); + x ^ count + }), + |x| x + ); + let mut seen = Vec::new(); + both!( + data.iter().filter(move |&&x| { + seen.push(x); + seen.len() % 2 == 0 + }), + id + ); + let mut sum = 0u8; + front!( + data.iter().inspect(move |&&x| sum = sum.wrapping_add(x)).map(|&x| x), + |x| x + ); + let mut steps = 0u8; + both!( + data.chunks(n).flat_map(move |c| { + steps += 1; + c.iter().map(move |x| x ^ steps) + }), + |x| x + ); + } + } +} + +/// `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. +fn unordered + Clone>(mut it: I, plan: &mut Plan<'_>, out: &mut Vec) { + let mut all: Vec = (0..plan.next() % 4).filter_map(|_| it.next()).collect(); + let other = it.clone(); + let (rest, other): (Vec, Vec) = (it.collect(), other.collect()); + out.extend([(rest == other) as u8, rest.len() as u8]); + all.extend(rest); + all.sort(); + out.extend(all); +} + +/// Iterators that own what they yield, each item cloned by its own `Clone` as the iterator +/// is, and dropped as each iterator drops. +fn owned(data: &[u8], plan: &mut Plan<'_>, out: &mut Vec) { + let log = Rc::new(RefCell::new(Vec::new())); + let logged = |id: u8| Logged { id, log: log.clone() }; + let items: Vec = data.iter().take(6).map(|&b| logged(b & 0x70)).collect(); + let mut it = items.into_iter(); + it.next(); + it.next_back(); + let clone = it.clone(); + flush(&log, out); + drop(it); + flush(&log, out); + turns(clone, |it| it.next_back(), plan, |x| x.id(), out); + flush(&log, out); + + let q: VecDeque = data.iter().take(4).map(|&b| logged(b & 0x70)).collect(); + turns(q.into_iter(), |it| it.next_back(), plan, |x| x.id(), out); + flush(&log, out); + + // Peeked, which clones after its iterator. + let items: Vec = data.iter().take(4).map(|&b| logged(b & 0x70)).collect(); + let mut it = items.into_iter().peekable(); + out.push(it.peek().map_or(0xee, Logged::id)); + let clone = it.clone(); + flush(&log, out); + drop(clone); + flush(&log, out); + turns(it, |it| it.next_back(), plan, |x| x.id(), out); + flush(&log, out); + + let it = std::iter::once(logged(1)).chain(Some(logged(2))); + let clone = it.clone(); + flush(&log, out); + drop(it); + turns(clone, |it| it.next_back(), plan, |x| x.id(), out); + flush(&log, out); + + // Each item of a flatten, and the inner iterator it holds at each end. + let rows: Vec> = data + .chunks(3) + .take(3) + .map(|c| c.iter().map(|&b| logged(b & 0x70)).collect()) + .collect(); + let mut it = rows.into_iter().flatten(); + it.next(); + it.next_back(); + let clone = it.clone(); + flush(&log, out); + drop(it); + flush(&log, out); + turns(clone, |it| it.next_back(), plan, |x| x.id(), out); + flush(&log, out); + + let mut it = std::iter::successors(Some(logged(40)), |x| x.id().checked_sub(13).map(|id| logged(id))); + it.next(); + let clone = it.clone(); + flush(&log, out); + turns(clone, |it| it.next(), plan, |x| x.id(), out); + drop(it); + flush(&log, out); +} + +/// Adaptors of closures that capture values that drop, which their clones clone and drop +/// with them, and closures cloned on their own. +fn closures(data: &[u8], plan: &mut Plan<'_>, out: &mut Vec) { + let log = Rc::new(RefCell::new(Vec::new())); + let logged = |id: u8| Logged { id, log: log.clone() }; + + let (a, b) = (logged(1), logged(2)); + let it = data.iter().map(move |&x| x ^ a.id()).filter(move |&x| x != b.id()); + let clone = it.clone(); + flush(&log, out); + drop(it); + flush(&log, out); + turns(clone, |it| it.next_back(), plan, |x| x, out); + flush(&log, out); + + // Captured with state that changes and a value that drops, in that order. + let (tag, mut count) = (logged(3), 0u8); + let mut it = data.iter().map(move |&x| { + count = count.wrapping_add(tag.id()); + x ^ count + }); + it.next(); + let mut clone = it.clone(); + flush(&log, out); + out.extend(it.next()); + out.extend(clone.next()); + out.extend(clone.next()); + out.extend(it.next()); + drop(clone); + flush(&log, out); + drop(it); + flush(&log, out); + + // A closure that holds a clone of another, cloned on its own and called. + let inner = logged(5); + let mut total = 0u8; + let mut add = move |x: u8| { + total = total.wrapping_add(x ^ inner.id()); + total + }; + out.push(add(1)); + let held = logged(6); + let mut outer = move |x: u8| add(x) ^ held.id(); + let mut copy = outer.clone(); + flush(&log, out); + out.extend([outer(2), copy(3), copy(4), outer(5)]); + drop(outer); + flush(&log, out); + drop(copy); + flush(&log, out); + + // A closure called once, which moves what it captured out, cloned first. + let mut text = String::from("ab"); + let tag = logged(7); + let once = move || { + text.push('c'); + (text, tag) + }; + let twice = once.clone(); + flush(&log, out); + let (text, tag) = once(); + out.extend(text.bytes().chain([tag.id()])); + drop(tag); + let (text, tag) = twice(); + out.extend(text.bytes().chain([tag.id()])); + drop(tag); + flush(&log, out); + + // A closure that shares what it captured, each clone of which is the closure. + let k = data.len() as u8; + let shared = move |x: &u8| x.wrapping_mul(k); + let it = data.iter().map(shared); + let clone = it.clone().rev(); + out.extend(it.zip(clone).map(|(x, y)| x ^ y)); +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index bddf9ab6d..e5701f56d 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -2,10 +2,10 @@ //! case and the rest is its input. use crate::{ - arrays, atomics, borrows, bounds, captures, cells, chars, chunks, collections, combinators, counts, cows, defaults, - durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, hints, holds, ints, iters, keys, locals, - locks, nested, objects, orders, pointers, refs, shapes, singles, slices, splits, statics, strs, utf8, wrappers, - zeros, + arrays, atomics, borrows, bounds, captures, cells, chars, chunks, clones, collections, combinators, counts, cows, + defaults, durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, hints, holds, ints, iters, keys, + locals, locks, nested, objects, orders, pointers, refs, shapes, singles, slices, splits, statics, strs, utf8, + wrappers, zeros, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -180,6 +180,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("iters::zips_back", iters::zips_back), ("collections::own_nes", collections::own_nes), ("fmt::iters", |_, data, out| fmt::iters(data, out)), + ("clones::iters", clones::iters), ] } diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 625f14829..e584f3340 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -29,6 +29,7 @@ mod captures; mod cells; mod chars; mod chunks; +mod clones; mod collections; mod combinators; mod counts; diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index b1e191665..a4023affe 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -18,6 +18,7 @@ import { ByteSlice, ByteVec, type None, type Place, panic, type RangeBound, rang import type { Hashing } from "./hash.ts"; import { type Limbs, lt } from "./int.ts"; import { + type Clones, DONE, type Done, exactHint, @@ -776,9 +777,21 @@ export class HashIter extends Iter implements Disposable { return acc; } - /** A fresh iterator of the same map, past what this one took: the map is unchanged while it is held. */ override remaining(): Iterable { - const it = new HashIter(this.h, byValue(this.pick)); + return this.from(byValue(this.pick)); + } + + /** std's, of an iterator that borrows the map: where it is, independently of it. */ + override clone(): Iter { + return this.from(this.pick); + } + + /** + * A fresh iterator of the same map yielding `pick`, past what this one took: the map is + * unchanged while it is held, and JS can't copy where its own iterator is. + */ + private from(pick: Pick): HashIter { + const it = new HashIter(this.h, pick); while (it.left > this.left) it.next(); return it; } @@ -1576,6 +1589,11 @@ export class BTreeIter extends Iter implements Disposable { return new BTreeIter(byValue(this.pick), this.fl, this.fi, this.bl, this.bi); } + /** std's, of an iterator that borrows the map. */ + override clone(): Iter { + return new BTreeIter(this.pick, this.fl, this.fi, this.bl, this.bi, this.n); + } + override len(): number { return this.n; } @@ -1844,11 +1862,20 @@ abstract class Merge extends Iter { private held: K | Done = DONE; private heldA = false; - constructor(a: BTreeSet, b: BTreeSet) { + constructor(a: Iter, b: Iter, c: (a: K, b: K) => Ordering) { super(); - this.a = btreeKeys(a); - this.b = btreeKeys(b); - this.c = a.c; + this.a = a; + this.b = b; + this.c = c; + } + + /** std's: each of its iterators, and the key it holds back. */ + override clone(): Iter { + const kind = this.constructor as new (a: Iter, b: Iter, c: (a: K, b: K) => Ordering) => Merge; + const it = new kind(this.a.clone(), this.b.clone(), this.c); + it.held = this.held; + it.heldA = this.heldA; + return it; } /** The next key of each, or `DONE` for one that ended or is held back. */ @@ -1900,12 +1927,12 @@ class SymmetricDifference extends Merge { /** `BTreeSet::union`: each key of either in order, `a`'s of two equal ones. */ export function btreeUnion(a: BTreeSet, b: BTreeSet): Iter { - return new Union(a, b); + return new Union(btreeKeys(a), btreeKeys(b), a.c); } /** `BTreeSet::symmetric_difference`: each key of one that the other lacks, in order. */ export function btreeSymmetricDifference(a: BTreeSet, b: BTreeSet): Iter { - return new SymmetricDifference(a, b); + return new SymmetricDifference(btreeKeys(a), btreeKeys(b), a.c); } /** @@ -1921,12 +1948,20 @@ class Difference extends Iter { private peek: K | Done = DONE; private peeked = false; - constructor(a: Iter, other: BTreeSet, search: boolean) { + constructor(a: Iter, set: BTreeSet | undefined, b: Iter, c: (a: K, b: K) => Ordering) { super(); this.a = a; - this.set = search ? other : undefined; - this.b = search ? iterEmpty() : btreeKeys(other); - this.c = other.c; + this.set = set; + this.b = b; + this.c = c; + } + + /** std's: each of its iterators, and the key it peeked. */ + override clone(): Iter { + const it = new Difference(this.a.clone(), this.set, this.b.clone(), this.c); + it.peek = this.peek; + it.peeked = this.peeked; + return it; } next(): K | Done { @@ -1972,7 +2007,8 @@ export function btreeDifference(a: BTreeSet, b: BTreeSet): Iter { if (low > 0 || high < 0) return keys; if (low === 0) keys.next(); else if (high === 0) keys.nextBack(); - else return new Difference(keys, b, a.n <= Math.floor(b.n / TIPPING)); + else if (a.n <= Math.floor(b.n / TIPPING)) return new Difference(keys, b, iterEmpty(), b.c); + else return new Difference(keys, undefined, btreeKeys(b), b.c); return keys; } @@ -1982,11 +2018,15 @@ class Intersection extends Iter { private readonly b: Iter; private readonly c: (a: K, b: K) => Ordering; - constructor(a: BTreeSet, b: BTreeSet) { + constructor(a: Iter, b: Iter, c: (a: K, b: K) => Ordering) { super(); - this.a = btreeKeys(a); - this.b = btreeKeys(b); - this.c = a.c; + this.a = a; + this.b = b; + this.c = c; + } + + override clone(): Iter { + return new Intersection(this.a.clone(), this.b.clone(), this.c); } next(): K | Done { @@ -2023,7 +2063,7 @@ export function btreeIntersection(a: BTreeSet, b: BTreeSet): Iter { if (high === 0) return iterOnce(aMax); if (a.n <= Math.floor(b.n / TIPPING)) return iterFilter(btreeKeys(a), (key) => btreeContains(b, key)); if (b.n <= Math.floor(a.n / TIPPING)) return iterFilter(btreeKeys(b), (key) => btreeContains(a, key)); - return new Intersection(a, b); + return new Intersection(btreeKeys(a), btreeKeys(b), a.c); } /** `BTreeSet::is_subset`: whether `b` holds each key of `a`. */ @@ -2472,6 +2512,15 @@ class DequeIter extends Iter implements Disposable { return new DequeIter(this.q, this.front, this.back); } + /** std's: where it is, or of `into_iter`, what it has left, each cloned in order by `h.v`. */ + override clone(h?: Clones): Iter { + if (h?.v === undefined) return new DequeIter(this.q, this.front, this.back, this.drop); + const clone = h.v as (item: T) => T; + const items: T[] = []; + for (let i = this.front; i < this.back; i++) items.push(clone(this.q.b[at(this.q, i)] as T)); + return iterSlice(items, this.drop); + } + override nextBack(): T | Done { return this.front < this.back ? (this.q.b[at(this.q, --this.back)] as T) : DONE; } diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index c1c615417..9462966f3 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -75,6 +75,25 @@ export interface Iter { len(): number; /** The items it has left, by value, without taking them: what std's `Debug` of it lists. */ remaining(): Iterable; + /** `Clone::clone`, reading on from where it is, independently of it, by `h`'s clones. */ + clone(h?: Clones): Iter; +} + +/** + * What clones the parts of one of std's iterators that it can't clone itself, as std's + * `Clone` of each does: `i` and `o` the iterators it wraps, `f` its closure, and `v` an item + * or another value it holds. A part without one clones as itself. + */ +export interface Clones { + readonly i?: Clones; + readonly o?: Clones; + readonly f?: (f: never) => unknown; + readonly v?: (value: never) => unknown; +} + +/** `value` cloned by `clone`, or itself. */ +function cloned(value: T, clone: ((value: never) => unknown) | undefined): T { + return clone === undefined ? value : (clone as (value: T) => T)(value); } /** `Iterator`: `next`, and the methods std's iterators each do their own way. */ @@ -1252,6 +1271,19 @@ class SliceIter extends Iter implements Disposable { return Array.prototype.slice.call(this.s, this.front, this.back); } + /** std's: what it has left, each cloned in order by `h.v` into storage of its own, or else shared. */ + override clone(h?: Clones): Iter { + if (h?.v !== undefined) { + const items = Array.prototype.slice.call(this.s, this.front, this.back) as T[]; + for (let i = 0; i < items.length; i++) items[i] = cloned(items[i], h.v); + return new SliceIter(items, this.drop); + } + const it = new SliceIter(this.s, this.drop); + it.front = this.front; + it.back = this.back; + return it; + } + [Symbol.dispose](): void { if (this.drop === undefined) return; const from = this.front; @@ -1361,6 +1393,13 @@ class PartsIter extends Iter { return this.part(this.s, start, Math.min(start + this.size, this.length)); } + override clone(): Iter { + const it = new PartsIter(this.s, this.length, this.size, this.step, this.count, this.rev, this.part); + it.front = this.front; + it.back = this.back; + return it; + } + /** What the parts leave over, at the end the parts don't start from. */ remainder(): S { const held = this.count * this.size; @@ -1425,6 +1464,10 @@ class OptionIter extends Iter implements Disposable { return this.some ? 1 : 0; } + override clone(h?: Clones): Iter { + return new OptionIter(this.some ? cloned(this.item as T, h?.v) : undefined, this.some, this.drop); + } + override sizeHint(): SizeHint { return exactHint(this.len()); } @@ -1453,6 +1496,11 @@ class FromNext extends Iter implements Disposable { return this.step(this.source); } + /** Its source cloned by `h.v`, as the crate's own `Clone` of it. */ + override clone(h?: Clones): Iter { + return new FromNext(cloned(this.source, h?.v), this.step, this.drop); + } + [Symbol.dispose](): void { const drop = this.drop; this.drop = undefined; @@ -1488,6 +1536,12 @@ class SuccessorsIter extends Iter implements Disposable { return this.item === this.none ? [0, 0] : [1, undefined]; } + /** std's: the item it holds next by `h.v`, then its closure by `h.f`. */ + override clone(h?: Clones): Iter { + const item = this.item === this.none ? this.item : cloned(this.item as T, h?.v); + return new SuccessorsIter(item, cloned(this.succ, h?.f), this.drop, this.none); + } + [Symbol.dispose](): void { if (this.dropped) return; this.dropped = true; @@ -1577,6 +1631,12 @@ class MapIter extends Calling U> { return new MapIter(inner, this.f); } + /** Its iterator by `h.i`, then `f` by `h.f`, as each kind that maps does. */ + override clone(h?: Clones): Iter { + const kind = this.constructor as new (inner: Iter, f: (item: T) => U) => MapIter; + return new kind(this.inner.clone(h?.i), cloned(this.f, h?.f)); + } + /** std's: `inner`'s, by a closure that drops `release`'s and then `f`. */ override fold(acc: A, g: (acc: A, item: U) => A, release?: () => void): A { return this.inner.fold(acc, mapFold(this.f, g), then(release, this.take())); @@ -1642,6 +1702,10 @@ class FilterIter extends Calling boolean> { return new FilterIter(inner, this.f, this.drop); } + override clone(h?: Clones): Iter { + return new FilterIter(this.inner.clone(h?.i), cloned(this.f, h?.f), this.drop); + } + /** std's: `inner`'s, by a closure that drops `f` and then `release`'s. */ override fold(acc: A, g: (acc: A, item: T) => A, release?: () => void): A { return this.inner.fold(acc, this.filterFold(g), then(this.take(), release)); @@ -1701,6 +1765,10 @@ class FilterMapIter extends Calling U | undefined | Non return new FilterMapIter(inner, this.f, this.none); } + override clone(h?: Clones): Iter { + return new FilterMapIter(this.inner.clone(h?.i), cloned(this.f, h?.f), this.none); + } + /** std's: `inner`'s, by a closure that drops `f` and then `release`'s. */ override fold(acc: A, g: (acc: A, item: U) => A, release?: () => void): A { return this.inner.fold(acc, this.filterMapFold(g), then(this.take(), release)); @@ -1720,6 +1788,12 @@ class FilterMapIter extends Calling U | undefined | Non class EnumerateIter extends Adaptor { index = 0; + override clone(h?: Clones): Iter<[number, T]> { + const it = new EnumerateIter(this.inner.clone(h?.i)); + it.index = this.index; + return it; + } + override sizeHint(): SizeHint { return this.inner.sizeHint(); } @@ -1797,12 +1871,17 @@ class ChainIter extends Iter implements Disposable { a: Iter | undefined; b: Iter | undefined; - constructor(a: Iter, b: Iter) { + constructor(a: Iter | undefined, b: Iter | undefined) { super(); this.a = a; this.b = b; } + /** std's: each half it still holds, the first by `h.i` and the second by `h.o`. */ + override clone(h?: Clones): Iter { + return new ChainIter(this.a?.clone(h?.i), this.b?.clone(h?.o)); + } + /** Drop `a`, which ended. */ endA(): void { const a = this.a; @@ -1951,6 +2030,10 @@ class ZipIter extends Iter<[A, B]> implements Disposable { this.dropB = dropB; } + override clone(h?: Clones): Iter<[A, B]> { + return new ZipIter(this.a.clone(h?.i), this.b.clone(h?.o), this.bounded, this.dropA, this.dropB); + } + /** std's `SpecFold` of two `TrustedLen` iterators, which `try_fold` doesn't share. */ override folded(fold = false): Iter<[A, B]> { return fold && this.bounded ? new ZipFold(this) : this; @@ -2046,6 +2129,14 @@ class TrustedZipIter extends ZipIter { this.end = Math.min(a.len(), b.len()); } + /** std's: its count of pairs read, with its iterators, which it reads by index as they are. */ + override clone(h?: Clones): Iter<[A, B]> { + const it = new TrustedZipIter(this.a.clone(h?.i), this.b.clone(h?.o), this.dropA, this.dropB); + it.index = this.index; + it.end = this.end; + return it; + } + override next(): [A, B] | Done { if (this.index >= this.end) return DONE; this.index++; @@ -2119,6 +2210,10 @@ class RevIter extends Adaptor { return new RevIter(inner); } + override clone(h?: Clones): Iter { + return new RevIter(this.inner.clone(h?.i)); + } + override fold(acc: A, f: (acc: A, item: T) => A, release?: () => void): A { return this.inner.rfold(acc, f, release); } @@ -2139,6 +2234,10 @@ class SkipIter extends Adaptor { this.drop = drop; } + override clone(h?: Clones): Iter { + return new SkipIter(this.inner.clone(h?.i), this.n, this.drop); + } + override sizeHint(): SizeHint { const [lower, upper] = this.inner.sizeHint(); return [Math.max(lower - this.n, 0), upper === undefined ? undefined : Math.max(upper - this.n, 0)]; @@ -2248,6 +2347,10 @@ class TakeIter extends Adaptor { this.drop = drop; } + override clone(h?: Clones): Iter { + return new TakeIter(this.inner.clone(h?.i), this.n, this.drop); + } + override sizeHint(): SizeHint { if (this.n === 0) return [0, 0]; const [lower, upper] = this.inner.sizeHint(); @@ -2365,6 +2468,12 @@ class SkipWhileIter extends Calling boolean> { this.drop = drop; } + override clone(h?: Clones): Iter { + const it = new SkipWhileIter(this.inner.clone(h?.i), cloned(this.f, h?.f), this.drop); + it.flag = this.flag; + return it; + } + next(): T | Done { return findItem( this.inner, @@ -2413,6 +2522,12 @@ class TakeWhileIter extends Calling boolean> { this.drop = drop; } + override clone(h?: Clones): Iter { + const it = new TakeWhileIter(this.inner.clone(h?.i), cloned(this.f, h?.f), this.drop); + it.flag = this.flag; + return it; + } + next(): T | Done { return this.from(this.inner); } @@ -2460,6 +2575,10 @@ class MapWhileIter extends Calling U | undefined | None return new MapWhileIter(inner, this.f, this.none); } + override clone(h?: Clones): Iter { + return new MapWhileIter(this.inner.clone(h?.i), cloned(this.f, h?.f), this.none); + } + override sizeHint(): SizeHint { return fewer(this.inner); } @@ -2478,6 +2597,12 @@ class StepByIter extends Adaptor { this.drop = drop; } + override clone(h?: Clones): Iter { + const it = new StepByIter(this.inner.clone(h?.i), this.step + 1, this.drop); + it.firstTake = this.firstTake; + return it; + } + next(): T | Done { const n = this.firstTake ? 0 : this.step; this.firstTake = false; @@ -2599,6 +2724,10 @@ class InspectIter extends Calling void> { return new InspectIter(inner, this.f); } + override clone(h?: Clones): Iter { + return new InspectIter(this.inner.clone(h?.i), cloned(this.f, h?.f)); + } + /** std's: `inner`'s, by a closure that drops `f` and then `release`'s. */ override fold(acc: A, g: (acc: A, item: T) => A, release?: () => void): A { return this.inner.fold(acc, this.inspectFold(g), then(this.take(), release)); @@ -2623,12 +2752,17 @@ class FuseIter extends Iter implements Disposable { /** Whether its iterator is a `FusedIterator`, which std's keeps once it ends. */ private readonly fused: boolean; - constructor(inner: Iter, fused: boolean) { + constructor(inner: Iter | undefined, fused: boolean) { super(); this.inner = inner; this.fused = fused; } + /** std's: its iterator, while it holds it. */ + override clone(h?: Clones): Iter { + return new FuseIter(this.inner?.clone(h?.i), this.fused); + } + override sizeHint(): SizeHint { return this.inner?.sizeHint() ?? [0, 0]; } @@ -2710,7 +2844,7 @@ class FlattenIter extends Iter implements Disposable { front: Iter | undefined; back: Iter | undefined; - constructor(outer: Iter, into: (value: T) => Iter, fused: boolean, size?: number, oneShot = false) { + constructor(outer: Iter | undefined, into: (value: T) => Iter, fused: boolean, size?: number, oneShot = false) { super(); this.outer = outer; this.into = into; @@ -2719,6 +2853,14 @@ class FlattenIter extends Iter implements Disposable { this.oneShot = oneShot; } + /** std's: its source by `h.i`, while it holds it, then its front and back by `h.o`. */ + override clone(h?: Clones): Iter { + const it = new FlattenIter(this.outer?.clone(h?.i), this.into, this.fused, this.size, this.oneShot); + it.front = this.front?.clone(h?.o); + it.back = this.back?.clone(h?.o); + return it; + } + /** * std's: what its front and back hold, and its source's items, if it knows how many * each has. Of items that hold at most one, only its source's, which std never holds @@ -2988,6 +3130,14 @@ export class Peekable extends Adaptor { this.drop = drop; } + /** std's: its iterator by `h.i`, then the item it peeked by `h.v`. */ + override clone(h?: Clones): Peekable { + const it = new Peekable(this.inner.clone(h?.i), this.drop); + it.peeked = this.peeked; + it.item = this.item === DONE ? DONE : cloned(this.item, h?.v); + return it; + } + /** The item it peeked, if any, which it no longer holds. */ take(): T | Done { this.peeked = false; @@ -3252,6 +3402,10 @@ export class Range extends Iter { override sizeHint(): SizeHint { return lt(this.start, this.end) ? stepsBetween(this.start, this.end) : [0, 0]; } + + override clone(): Range { + return new Range(this.start, this.end, this.int); + } } /** `Range::is_empty`. */ @@ -3264,11 +3418,6 @@ export function rangeContains(r: Range, item: T): boolean { return !lt(item, r.start) && lt(item, r.end); } -/** `Range::clone`. */ -export function rangeClone(r: Range): Range { - return new Range(r.start, r.end, r.int); -} - /** `ops::RangeInclusive`: `start..=end`, which remembers once it has yielded `end`. */ export class RangeInclusive extends Iter { lo: T; @@ -3296,6 +3445,12 @@ export class RangeInclusive extends Iter { return new RangeInclusiveFold(this); } + override clone(): RangeInclusive { + const range = new RangeInclusive(this.lo, this.hi, this.int); + range.exhausted = this.exhausted; + return range; + } + override nextBack(): T | Done { if (rangeInclusiveIsEmpty(this)) return DONE; const hi = this.hi; @@ -3390,13 +3545,6 @@ export function rangeInclusiveContains(r: RangeInclusive, item: T): boolea return !r.exhausted && !lt(item, r.lo) && !lt(r.hi, item); } -/** `RangeInclusive::clone`. */ -export function rangeInclusiveClone(r: RangeInclusive): RangeInclusive { - const range = new RangeInclusive(r.lo, r.hi, r.int); - range.exhausted = r.exhausted; - return range; -} - /** `RangeInclusive::start_bound`: its start, included. */ export function rangeInclusiveStartBound(r: RangeInclusive): RangeBound { return { tag: "Included", _0: r.lo }; diff --git a/ts/runtime/rt/str.ts b/ts/runtime/rt/str.ts index 0f4e53a0c..a313654c7 100644 --- a/ts/runtime/rt/str.ts +++ b/ts/runtime/rt/str.ts @@ -9,7 +9,7 @@ import { fmtCharDebug, type Place, panic, panicFmt, stringLen } from "../rt.ts"; import { type Bounds, boundsRange } from "./collections.ts"; import type { char, u8, usize } from "./int.ts"; -import { DONE, type Done, Iter, iterForEach, iterSlice, type SizeHint } from "./iter.ts"; +import { type Clones, DONE, type Done, Iter, iterForEach, iterSlice, type SizeHint } from "./iter.ts"; import { drop as dispose } from "./task.ts"; const encoder = /* @__PURE__ */ new TextEncoder(); @@ -132,8 +132,16 @@ class Chars extends Iter { return this.#s.slice(this.#front, this.#back); } + override clone(): Iter { + const it = new Chars(this.#s); + it.#front = this.#front; + it.#back = this.#back; + return it; + } + + /** std's `Debug` lists a clone. */ override remaining(): Iterable { - return new Chars(this.rest()); + return this.clone(); } } @@ -158,6 +166,17 @@ class Searcher { this.#back = s.length; } + /** std's: where it is, with its pattern cloned by `h.f`, a closure's as Rust clones it. */ + clone(h: Clones | undefined): Searcher { + const m = new Searcher(this.s, h?.f === undefined ? this.#p : (h.f as (p: Pattern) => Pattern)(this.#p)); + m.#front = this.#front; + m.#back = this.#back; + m.#matched = this.#matched; + m.start = this.start; + m.end = this.end; + return m; + } + nextMatch(): boolean { const { s } = this; const p = this.#p; @@ -237,6 +256,14 @@ class Split extends Iter { this.#end = m.s.length; } + override clone(h?: Clones): Iter { + const it = new Split(this.#m.clone(h)); + it.#start = this.#start; + it.#end = this.#end; + it.#finished = this.#finished; + return it; + } + next(): string | Done { if (this.#finished) return DONE; const m = this.#m; @@ -281,6 +308,15 @@ class MatchIndices extends Iter<[usize, string]> { this.#m = m; } + override clone(h?: Clones): Iter<[usize, string]> { + const it = new MatchIndices(this.#m.clone(h)); + it.#front = this.#front; + it.#frontBytes = this.#frontBytes; + it.#back = this.#back; + it.#backBytes = this.#backBytes; + return it; + } + next(): [usize, string] | Done { const m = this.#m; if (!m.nextMatch()) return DONE; diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rt/task.ts index aa1572658..694f0eb84 100644 --- a/ts/runtime/rt/task.ts +++ b/ts/runtime/rt/task.ts @@ -26,13 +26,30 @@ export function dropRange(values: ArrayLike, f: (value: T) => void, from: // Closures. One that owns a value that drops is an arrow function with // `[Symbol.dispose]`, which drops what it owns. Calling one that `FnOnce` calls consumes // it, as its body drops what it owns; one that `Fn` or `FnMut` call drops after a call -// through `FnOnce`, as rustc's shim does. +// through `FnOnce`, as rustc's shim does. One whose clone can't be itself is made by a +// function of its captures, which makes the clone again of theirs. /** A closure `f`, which owns what `dispose` drops. */ export function closure unknown>(f: F, dispose: () => void): F & Disposable { return Object.assign(f, { [Symbol.dispose]: dispose }); } +/** What makes a closure's clone, of one that a clone can't share. */ +const CLONE: unique symbol = /* @__PURE__ */ Symbol("clone"); + +/** + * A closure `f` whose `Clone` is `clone`: one that writes what it captured, or captured + * what clones other than as itself, made again of its captures' clones. + */ +export function cloning unknown>(f: F, clone: () => F): F { + return Object.assign(f, { [CLONE]: clone }); +} + +/** `Clone::clone` of a closure that `cloning` made. */ +export function closureClone(f: F): F { + return (f as F & { [CLONE]: () => F })[CLONE](); +} + /** `FnOnce::call_once` of a closure that `Fn` or `FnMut` call: `f(...args)`, then `f` drops. */ export function callOnce(f: (...args: A) => R, ...args: A): R { const r = f(...args); diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 85f23dbc0..fa91ec28a 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -2021,9 +2021,13 @@ pub fn clone_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> E { return copy; } - if library::clone_copies(b.t, ty) || library::string(tcx, ty) { + if library::clone_copies(b.t, ty) || library::clone_shares(b.t, ty) { return Expr::undefined(); } + if let ty::Closure(def_id, _) = ty.kind() { + b.t.clone_closure(*def_id); + return Expr::Rt("closureClone".into()); + } let clone = trait_fn(tcx, "Clone", "clone"); b.fn_value(clone, tcx.mk_args(&[ty.into()]), span) } diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index d4642feed..7b420916b 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -12,7 +12,7 @@ use super::Translator; use super::body::Body; use super::library::{self, Call, Std}; use super::num::Int; -use crate::ts::{Expr, Param, Type}; +use crate::ts::{Expr, Key, Param, Type}; /// `Iterator::next`, and the trait's `Item`. fn trait_items(tcx: ty::TyCtxt<'_>) -> Option<(DefId, DefId)> { @@ -834,6 +834,111 @@ fn bind_params<'tcx>(pattern: Ty<'tcx>, ty: Ty<'tcx>, found: &mut Vec<(u32, Ty<' } } +/// `Clone::clone` of `value`, one of std's iterators of type `ty`: its `clone`, given what +/// clones what the runtime can't clone itself, or `None` for one std's has no mapping of. +pub(super) fn clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, span: Span) -> Option { + let clones = clones(b, ty, span)?; + 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 +/// 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`. +fn clones<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option { + let tcx = b.t.tcx; + let value = |b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>| super::collections::clone_fn(b, ty, span); + if own_next(b, ty).is_some() { + return Some(parts(vec![("v", value(b, ty))])); + } + let ty::Adt(adt, args) = ty.kind() else { + return None; + }; + let arg = |n: usize| args.types().nth(n); + let path = library::std_path(tcx, adt.did()); + let path: Vec<&str> = path.iter().map(String::as_str).collect(); + Some(match path.as_slice() { + // Those that borrow what they read, as their clones do too. + [ + "slice", + "iter", + "Iter" | "Windows" | "Chunks" | "ChunksExact" | "RChunks" | "RChunksExact", + ] + | ["str", "iter", "Chars" | "Bytes"] + | ["option", "Iter"] + | ["ops", "range", "Range" | "RangeInclusive"] + | ["collections", "vec_deque", "iter", "Iter"] + | ["collections", "binary_heap", "Iter"] + | ["collections", "btree", "map", "Iter" | "Keys" | "Values" | "Range"] + | ["collections", "hash", "map", "Iter" | "Keys" | "Values"] + | [ + "collections", + "btree" | "hash", + "set", + "Iter" | "Range" | "Difference" | "Intersection" | "Union" | "SymmetricDifference", + ] => Expr::undefined(), + // Those that own their items, each cloned. + ["vec", "into_iter", "IntoIter"] + | ["array", "iter", "IntoIter"] + | ["option", "IntoIter"] + | ["iter", "sources", "once", "Once"] + | ["collections", "vec_deque", "into_iter", "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. + ["str", "iter", "Split" | "MatchIndices"] => match arg(0)?.kind() { + ty::Closure(..) => parts(vec![("f", value(b, arg(0)?))]), + _ => Expr::undefined(), + }, + // Its closure is what `rt.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)?))]) + } + [ + "iter", + "adapters", + _, + "Map" | "Filter" | "FilterMap" | "SkipWhile" | "TakeWhile" | "MapWhile" | "Inspect", + ] => parts(vec![("i", clones(b, arg(0)?, span)?), ("f", value(b, arg(1)?))]), + [ + "iter", + "adapters", + _, + "Enumerate" | "Skip" | "Take" | "StepBy" | "Fuse" | "Rev" | "Copied" | "Cloned", + ] => parts(vec![("i", clones(b, arg(0)?, span)?)]), + ["iter", "adapters", _, "Chain" | "Zip"] => { + parts(vec![("i", clones(b, arg(0)?, span)?), ("o", clones(b, arg(1)?, span)?)]) + } + ["iter", "adapters", "peekable", "Peekable"] => { + let item = b.t.iter_item(arg(0)?)?; + parts(vec![("i", clones(b, arg(0)?, span)?), ("v", value(b, item))]) + } + // Its source, as `map` makes it, and the iterators of what that yields. + ["iter", "adapters", "flatten", "FlatMap"] => { + let source = parts(vec![("i", clones(b, arg(0)?, span)?), ("f", value(b, arg(2)?))]); + let inner = iter_of(b.t, arg(1)?)?; + parts(vec![("i", source), ("o", clones(b, inner, span)?)]) + } + ["iter", "adapters", "flatten", "Flatten"] => { + let inner = iter_of(b.t, b.t.iter_item(arg(0)?)?)?; + parts(vec![("i", clones(b, arg(0)?, span)?), ("o", clones(b, inner, span)?)]) + } + _ => return None, + }) +} + +/// An `rt.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)) + .map(|(name, e)| (Key::Name(name.into()), e)) + .collect(); + match parts.is_empty() { + true => Expr::undefined(), + false => Expr::Object(parts), + } +} + /// Whether std's iterator `did` holds a closure that its `rt.Iter` drops after the iterator /// it wraps, as std's fields order them. pub(super) fn holds_closure(tcx: ty::TyCtxt<'_>, did: DefId) -> bool { diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 770c01a86..725767870 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -545,6 +545,21 @@ pub fn clone_copies<'tcx>(t: &super::Translator<'_, 'tcx>, ty: Ty<'tcx>) -> bool t.is_copy(ty) && clone_only_copies(t, ty) } +/// Whether `Clone` of `ty` is the value itself, as JS holds it: a string, a function, or a +/// closure that writes none of its captures, each of which only copies or clones so, as +/// nothing else reaches what a closure owns to write it. +pub fn clone_shares<'tcx>(t: &super::Translator<'_, 'tcx>, ty: Ty<'tcx>) -> bool { + match ty.kind() { + ty::FnDef(..) => true, + ty::Closure(_, args) => { + !super::mir::writes_captures(t.tcx, ty) + && (args.as_closure().upvar_tys().iter()) + .all(|capture| clone_copies(t, capture) || clone_shares(t, capture)) + } + _ => string(t.tcx, ty), + } +} + /// Whether `Clone` of `ty`, a `Copy` type, only copies. fn clone_only_copies<'tcx>(t: &super::Translator<'_, 'tcx>, ty: Ty<'tcx>) -> bool { let tcx = t.tcx; @@ -1177,14 +1192,6 @@ fn mapping<'tcx>( let is_u8 = |t: Ty<'tcx>| matches!(t.kind(), ty::Uint(ty::UintTy::U8)); let byte_slice = |t: Ty<'tcx>| matches!(t.kind(), ty::Slice(e) if is_u8(*e)); let range = matches!(inherent_std(tcx, call.def_id), Some(Std::Range | Std::RangeInclusive)); - // A range of integers, whose comparisons and clones JS makes as Rust does. - let int_range = |t: Ty<'tcx>| match t.peel_refs().kind() { - ty::Adt(adt, args) => { - matches!(Std::of(tcx, adt.did()), Some(Std::Range | Std::RangeInclusive)) - && Int::of(args.type_at(0)).is_some() - } - _ => false, - }; let e = match (owner.as_str(), name.as_str()) { // Conversions. @@ -1343,9 +1350,12 @@ fn mapping<'tcx>( 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]), - ty::Adt(adt, _) if int_range(ty) => { - Expr::rt_of(range_of(Std::of(tcx, adt.did())?)?, "clone").call(vec![value]) + _ if b.t.std_iter(ty) => return super::iter::clone(b, ty, value, span), + ty::Closure(def_id, _) if !clone_shares(b.t, ty) => { + b.t.clone_closure(*def_id); + Expr::rt("closureClone", vec![value]) } + _ if clone_shares(b.t, ty) => value, _ if clone_copies(b.t, ty) => b.t.copied(value, ty, span), _ => return None, } diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index ab13c934f..991775756 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -31,7 +31,7 @@ use rustc_middle::ty::{self, EarlyBinder, Instance, Ty, TyCtxt}; use rustc_span::{Span, Spanned}; use self::cfg::Exit; -pub use self::place::slice_member; +pub use self::place::{slice_member, writes_captures}; use super::Translator; use super::body::Body; diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index aae942546..9455d5dc4 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -1698,15 +1698,10 @@ pub fn transparent<'tcx>(t: &crate::lower::Translator<'_, 'tcx>, ty: Ty<'tcx>) - /// nothing when written. fn changes_captures<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { match ty.kind() { - ty::Closure(def_id, args) => { + ty::Closure(_, args) => { let closure = args.as_closure(); - let upvars = closure.upvar_tys(); - let writes = closure.kind() == ty::ClosureKind::FnMut - && (!tcx.is_mir_available(*def_id) - || written_captures(tcx.optimized_mir(*def_id)) - .into_iter() - .any(|field| upvars.get(field.index()).is_none_or(|t| !stateless(*t)))); - writes || upvars.iter().any(|t| changes_captures(tcx, t)) + let writes = closure.kind() == ty::ClosureKind::FnMut && writes_captures(tcx, ty); + writes || closure.upvar_tys().iter().any(|t| changes_captures(tcx, t)) } ty::Tuple(tys) => tys.iter().any(|t| changes_captures(tcx, t)), ty::Array(t, _) => changes_captures(tcx, *t), @@ -1715,6 +1710,19 @@ fn changes_captures<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { } } +/// Whether the body of `ty`, a closure, writes a capture that holds state, which a JS +/// closure sharing its variables would write for each copy of it. +pub fn writes_captures<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { + let ty::Closure(def_id, args) = ty.kind() else { + return false; + }; + let upvars = args.as_closure().upvar_tys(); + !tcx.is_mir_available(*def_id) + || written_captures(tcx.optimized_mir(*def_id)) + .into_iter() + .any(|field| upvars.get(field.index()).is_none_or(|t| !stateless(*t))) +} + /// Whether every value of `ty` is the same, so writing one changes nothing. fn stateless(ty: Ty<'_>) -> bool { match ty.kind() { diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 4ecc2d4e4..f1549bc37 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -14,7 +14,7 @@ use crate::lower::library::Std; use crate::lower::num::{self, Int}; use crate::lower::pointer::Pointee; use crate::lower::{AdtRepr, byte_array, field_name}; -use crate::ts::{Expr, Key, Stmt, StmtKind, Type}; +use crate::ts::{Expr, Key, Param, Stmt, StmtKind, Type}; impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// The value of `rvalue`, assigned to `dest`, or `None` if it has none to assign. @@ -680,12 +680,30 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { return Expr::undefined(); }; let rebound = rebound_captures(&mir); + // One whose clone can't share it is made by a function of its captures, whose + // parameters they are, with what they are now as its arguments. + let made = self.b.t.clones_closure(def_id); + let mut params = Vec::new(); + let mut values = Vec::new(); // A capture by reference reads the place it borrows; one by value is the value as // it was when the closure was made, a reference held in a variable included, which // a closure that assigns it whole reassigns. let mut captures = Vec::with_capacity(ops.len()); for (field, op) in ops.iter_enumerated() { let ty = op.ty(&self.mir.local_decls, tcx); + if made { + let name = self.b.fresh("captured"); + values.push(self.operand(op, span, out)); + params.push(Param { + name: name.clone(), + ty: Some(self.b.t.held_ty(ty, span)), + }); + captures.push(Capture { + value: Expr::ident(name), + pointee: false, + }); + continue; + } // A `&mut` to a borrowed place the closure reads and writes as a JS closure does, // so it can replace an object there whole, as `mem::take` does. if let Some(local) = op.place().and_then(|p| p.as_local()) @@ -736,14 +754,40 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { false => None, }; let mut inner = Fx::new(&mut *self.b, &mir, Env::Closure(captures), span); - let params = inner.params(); + let inputs = inner.params(); let body = inner.lower(); - let f = Expr::Arrow(params, ret, body); + let mut f = Expr::Arrow(inputs, ret, body); + let make = made.then(|| self.b.fresh("make")); + if let Some(make) = &make { + // Its clone, made again of each capture's, in order, as rustc's clones them. + let upvars = args.as_closure().upvar_tys(); + let clones = std::iter::zip(¶ms, upvars) + .map(|(param, ty)| { + let value = Expr::ident(¶m.name); + match crate::lower::collections::clone_fn(self.b, ty, span) { + Expr::Lit(l) if l == "undefined" => value, + clone => clone.call(vec![value]), + } + }) + .collect(); + let again = Expr::Lambda(Vec::new(), Box::new(Expr::ident(make).call(clones))); + f = Expr::rt("cloning", vec![f, again]); + } // One that owns what drops carries the glue that drops it. - match glue { - Some(glue) => Expr::rt("closure", vec![f, Expr::Arrow(Vec::new(), Type::Builtin("void"), glue)]), - None => f, + if let Some(glue) = glue { + f = Expr::rt("closure", vec![f, Expr::Arrow(Vec::new(), Type::Builtin("void"), glue)]); } + let Some(make) = make else { + return f; + }; + let fn_ty = self.b.t.ty(ty, span); + let made = Expr::Arrow(params, fn_ty, vec![StmtKind::Return(Some(f)).at(None)]); + self.emit( + vec![StmtKind::decl(false, make.clone(), None, Some(made)).at(None)], + false, + out, + ); + Expr::ident(make).call(values) } } diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 2bd2c5b90..21219a637 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -217,6 +217,11 @@ pub struct Translator<'a, 'tcx> { read: rustc_data_structures::fx::FxHashSet>, /// The instances whose bodies lowered from MIR, a closure's included. lowered: rustc_data_structures::fx::FxHashSet>, + /// The closures whose clones can't share them that the runs before reached, each made + /// by a function of its captures, which makes its clone too. + cloned: rustc_data_structures::fx::FxHashSet, + /// Those this run reached. + cloning: rustc_data_structures::fx::FxHashSet, /// The trait of each trait object, by its principal trait. objects: rustc_data_structures::fx::FxHashMap, /// The class wrapping each type as each trait object. @@ -342,7 +347,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// translation reaches runs, and of a generic body, only the instances it reaches, which /// it knows once it has reached them. So it runs again while it reaches a body whose /// writes it didn't read, or an instance of one writing a type parameter that it didn't - /// judge by. + /// judge by. A closure's clone may come before or after the closure is made, which + /// makes it as its clones need, so it runs again too when it reaches a new one. fn settle( tcx: TyCtxt<'tcx>, config: &'a Config, @@ -350,8 +356,9 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { mut reach: impl FnMut(&mut Self) -> R, ) -> Option<(Self, R)> { let mut read = rustc_data_structures::fx::FxHashSet::default(); + let mut cloned = rustc_data_structures::fx::FxHashSet::default(); loop { - let mut t = Self::new(tcx, config, census, read)?; + let mut t = Self::new(tcx, config, census, read, cloned)?; t.bind(); let out = reach(&mut t); let reached: Vec> = t @@ -361,19 +368,33 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { .copied() .filter(|&instance| t.crates.translates(instance.def_id()) && t.writes.unread(instance)) .collect(); - if reached.is_empty() { + if reached.is_empty() && t.cloning.is_subset(&t.cloned) { return Some((t, out)); } read = std::mem::take(&mut t.read); read.extend(reached); + cloned = std::mem::take(&mut t.cloned); + cloned.extend(t.cloning.drain()); } } + /// Note a clone of the closure `def_id` that can't share it. + pub fn clone_closure(&mut self, def_id: DefId) { + self.cloning.insert(def_id); + } + + /// Whether a clone of the closure `def_id` that can't share it was reached, so it is + /// made by a function of its captures. + pub fn clones_closure(&self, def_id: DefId) -> bool { + self.cloned.contains(&def_id) + } + fn new( tcx: TyCtxt<'tcx>, config: &'a Config, census: bool, read: rustc_data_structures::fx::FxHashSet>, + cloned: rustc_data_structures::fx::FxHashSet, ) -> Option { if tcx.data_layout.pointer_size().bits() != 32 { tcx.dcx().err( @@ -410,6 +431,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { writes: Default::default(), read, lowered: Default::default(), + cloned, + cloning: Default::default(), held: false, sites: Default::default(), site: None, From b5d0eba62cf1f8ff7071d46945e40da2c94565fb Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 19:41:13 -0700 Subject: [PATCH 3/3] feat(ts): clone a start.. as the other ranges, after merging main #320 made start.. an rt.RangeFrom iterator while this branch removed rt.rangeClone, so RangeFrom gets its own clone() and the iterator clone mapping takes it. Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/clones.ts | 755 ++++++++++++++++++--------- ts/fixtures/lang/expected/harness.ts | 7 +- ts/fixtures/lang/src/clones.rs | 4 + ts/src/lower/iter.rs | 2 +- 4 files changed, 514 insertions(+), 254 deletions(-) diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index c8a7df96b..98189eefa 100644 --- a/ts/fixtures/lang/expected/clones.ts +++ b/ts/fixtures/lang/expected/clones.ts @@ -20,7 +20,7 @@ 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$Bytes_iters_closure49_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$Bytes_iters_closure55_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -100,7 +100,7 @@ export function turns$Bytes_iters_closure49_iters_closure50(it: rt.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$Chain_Iter_u8_Skip_Rev_Iter_u8_iters_closure79_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$Chain_Iter_u8_Skip_Rev_Iter_u8_iters_closure85_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -262,7 +262,7 @@ export function turns$Chain_Once_Logged_IntoIter_Logged_owned_closure10_owned_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$Chars_iters_closure47_iters_closure48(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$Chars_iters_closure53_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 { let first!: boolean; let item3!: rt.char | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -502,7 +502,7 @@ export function turns$Chunks_u8_iters_closure24_iters_closure25(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$Cloned_Iter_u8_iters_closure82_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -582,7 +582,7 @@ export function turns$Cloned_Iter_u8_iters_closure76_iters_closure77(it: rt.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$Copied_Iter_u8_iters_closure74_iters_closure75(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$Copied_Iter_u8_iters_closure80_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -662,7 +662,7 @@ export function turns$Copied_Iter_u8_iters_closure74_iters_closure75(it: rt.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$Difference_u8_iters_closure129_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$Difference_u8_iters_closure135_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -742,7 +742,7 @@ export function turns$Difference_u8_iters_closure129_iters_closure0(it: rt.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$Difference_u8_iters_closure130_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$Difference_u8_iters_closure136_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -822,7 +822,7 @@ export function turns$Difference_u8_iters_closure130_iters_closure0(it: rt.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$Empty_u8_iters_closure45_iters_closure46(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$Empty_u8_iters_closure51_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -902,7 +902,7 @@ export function turns$Empty_u8_iters_closure45_iters_closure46(it: rt.Iter, 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$Enumerate_Iter_u8_iters_closure74_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 { 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 => { @@ -982,7 +982,7 @@ export function turns$Enumerate_Iter_u8_iters_closure68_iters_closure69(it: rt.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$FilterMap_Iter_u8_iters_closure65_iters_closure66_iters_closure67(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$FilterMap_Iter_u8_iters_closure71_iters_closure72_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1062,7 +1062,7 @@ export function turns$FilterMap_Iter_u8_iters_closure65_iters_closure66_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$Filter_Iter_u8_iters_closure141_iters_closure142_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$Filter_Iter_u8_iters_closure147_iters_closure148_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1142,7 +1142,7 @@ export function turns$Filter_Iter_u8_iters_closure141_iters_closure142_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$Filter_Iter_u8_iters_closure63_iters_closure64_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$Filter_Iter_u8_iters_closure69_iters_closure70_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1304,7 +1304,7 @@ export function turns$Filter_Map_Iter_u8_closures_closure1_closures_closure2_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$FlatMap_Chunks_u8_Iter_u8_iters_closure81_iters_closure82_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$FlatMap_Chunks_u8_Iter_u8_iters_closure87_iters_closure88_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1384,7 +1384,7 @@ export function turns$FlatMap_Chunks_u8_Iter_u8_iters_closure81_iters_closure82_ * 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$FlatMap_Chunks_u8_Map_Iter_u8_iters_closure147_closure0_iters_closure147_iters_closure148_iters_closure149(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$FlatMap_Chunks_u8_Map_Iter_u8_iters_closure153_closure0_iters_closure153_iters_closure154_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1464,7 +1464,7 @@ export function turns$FlatMap_Chunks_u8_Map_Iter_u8_iters_closure147_closure0_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$Flatten_Chunks_u8_iters_closure86_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$Flatten_Chunks_u8_iters_closure92_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1628,7 +1628,7 @@ export function turns$Flatten_IntoIter_Vec_Logged_owned_closure13_owned_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$Flatten_Map_Chunks_u8_iters_closure83_iters_closure84_iters_closure85(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$Flatten_Map_Chunks_u8_iters_closure89_iters_closure90_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1708,7 +1708,7 @@ export function turns$Flatten_Map_Chunks_u8_iters_closure83_iters_closure84_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$FromFn_iters_closure99_iters_closure100_iters_closure101(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$FromFn_iters_closure105_iters_closure106_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1788,7 +1788,7 @@ export function turns$FromFn_iters_closure99_iters_closure100_iters_closure101(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$Fuse_Iter_u8_iters_closure78_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$Fuse_Iter_u8_iters_closure84_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1868,7 +1868,7 @@ export function turns$Fuse_Iter_u8_iters_closure78_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$Intersection_u8_iters_closure133_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -1948,7 +1948,7 @@ export function turns$Intersection_u8_iters_closure127_iters_closure0(it: rt.Ite * 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$Intersection_u8_iters_closure128_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$Intersection_u8_iters_closure134_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -2192,7 +2192,7 @@ export function turns$IntoIter_Logged_owned_closure5_owned_closure6(it: rt.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$IntoIter_u8_iters_closure133_iters_closure134(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$IntoIter_u8_iters_closure139_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -2272,7 +2272,7 @@ export function turns$IntoIter_u8_iters_closure133_iters_closure134(it: rt.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$IntoIter_u8_iters_closure136_iters_closure137(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$IntoIter_u8_iters_closure142_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -2512,7 +2512,7 @@ export function turns$IntoIter_u8_iters_closure20_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$IntoIter_u8_iters_closure46_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -2592,7 +2592,7 @@ export function turns$IntoIter_u8_iters_closure40_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$IntoIter_u8_iters_closure47_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -2672,7 +2672,7 @@ export function turns$IntoIter_u8_iters_closure41_iters_closure42(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_u8_iters_closure130_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -2752,7 +2752,7 @@ export function turns$Iter_u8_iters_closure124_iters_closure0(it: rt.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_u8_iters_closure132_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_u8_iters_closure138_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -2832,7 +2832,7 @@ export function turns$Iter_u8_iters_closure132_iters_closure0(it: rt.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_u8_iters_closure135_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_u8_iters_closure141_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -2992,7 +2992,7 @@ export function turns$Iter_u8_iters_closure17_iters_closure0(it: rt.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_u8_u8_iters_closure116_iters_closure117(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_u8_u8_iters_closure122_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 { 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 => { @@ -3152,7 +3152,7 @@ export function turns$Iter_u8s_iters_closure32_iters_closure33(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$Keys_u8_u8_iters_closure124_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -3232,7 +3232,7 @@ export function turns$Keys_u8_u8_iters_closure118_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$MapWhile_Iter_u8_iters_closure97_iters_closure98_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -3312,7 +3312,7 @@ export function turns$MapWhile_Iter_u8_iters_closure91_iters_closure92_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$Map_Countdown_iters_closure94_iters_closure95_iters_closure96(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$Map_Countdown_iters_closure100_iters_closure101_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -3392,7 +3392,7 @@ export function turns$Map_Countdown_iters_closure94_iters_closure95_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$Map_Inspect_Iter_u8_iters_closure143_iters_closure144_iters_closure145_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$Map_Inspect_Iter_u8_iters_closure149_iters_closure150_iters_closure151_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -3472,7 +3472,7 @@ export function turns$Map_Inspect_Iter_u8_iters_closure143_iters_closure144_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$Map_Iter_u8_iters_closure138_iters_closure139_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$Map_Iter_u8_iters_closure144_iters_closure145_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -3552,7 +3552,7 @@ export function turns$Map_Iter_u8_iters_closure138_iters_closure139_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$Map_Iter_u8_iters_closure60_iters_closure61_iters_closure62(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$Map_Iter_u8_iters_closure66_iters_closure67_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -3632,7 +3632,7 @@ export function turns$Map_Iter_u8_iters_closure60_iters_closure61_iters_closure6 * 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$MatchIndices_chars_iters_closure58_iters_closure59(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$MatchIndices_chars_iters_closure64_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 { 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 => { @@ -3712,7 +3712,7 @@ export function turns$MatchIndices_chars_iters_closure58_iters_closure59(it: rt. * 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$Once_u8_iters_closure43_iters_closure44(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$Once_u8_iters_closure49_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -3792,7 +3792,7 @@ export function turns$Once_u8_iters_closure43_iters_closure44(it: rt.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$Peekable_Copied_Iter_u8_iters_closure114_iters_closure115(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$Peekable_Copied_Iter_u8_iters_closure120_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Peekable) => Uint8Array = (it2: rt.Peekable): Uint8Array => { @@ -3954,7 +3954,7 @@ export function turns$Peekable_IntoIter_Logged_owned_closure8_owned_closure9(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$Peekable_Iter_u8_iters_closure113_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$Peekable_Iter_u8_iters_closure119_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Peekable) => Uint8Array = (it2: rt.Peekable): Uint8Array => { @@ -4034,7 +4034,7 @@ export function turns$Peekable_Iter_u8_iters_closure113_iters_closure0(it: rt.Pe * 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$Peekable_Iter_u8_iters_closure80_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$Peekable_Iter_u8_iters_closure86_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Peekable) => Uint8Array = (it2: rt.Peekable): Uint8Array => { @@ -4269,6 +4269,246 @@ export function turns$RChunks_u8_iters_closure28_iters_closure29(it: rt.Iter, back: (a0: rt.RangeFrom) => rt.char | undefined, plan: Plan.Plan, put: (a0: rt.char) => rt.u8, out: rt.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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.char | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.char | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$RangeFrom_u64_iters_closure42_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u64 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u64 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + +/** + * `it` read up to three times from the front and then from the back by `back`, cloned, and + * 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$RangeFrom_u8_iters_closure40_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 { + 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, mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + return n & 0xff; + })); + }; + const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _8; + while (iterStart++ < iterEnd) { + const _15: rt.u8 | rt.Done = it.next(); + if (_15 !== rt.DONE) { + rt.byteVecPush(out, put(_15)); + } + } + const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = _25; + while (iterStart2++ < iterEnd2) { + const _32: rt.u8 | undefined = back(it); + if (_32 !== undefined) { + rt.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); + let ended: boolean = false; + let otherEnded: boolean = false; + let iterStart3: rt.i32 = 0; + const iterEnd3: rt.i32 = 64; + while (iterStart3++ < iterEnd3) { + if (ended) { + if (otherEnded) { + break; + } + } + const step: rt.u8 = Plan.next(plan); + b7: { + if ((step & 1) === 0) { + if (!ended) { + first = true; + break b7; + } + } + first = otherEnded; + } + const _73: [boolean, boolean] = [first, (step & 2) === 0]; + if (!_73[0]) { + if (!_73[1]) { + item3 = back(other); + } else { + item3 = rt.iterToOption(other.next()); + } + } else if (!_73[1]) { + item3 = back(it); + } else { + item3 = rt.iterToOption(it.next()); + } + if (item3 === undefined) { + if (!first) { + otherEnded = true; + } else { + ended = true; + } + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + } else { + rt.byteVecPush(out, put(item3)); + } + } +} + /** * `it` read up to three times from the front and then from the back by `back`, cloned, and * then the original and the clone read in turns, each from either end, as `plan` picks, @@ -4434,7 +4674,7 @@ export function turns$Range_u64_iters_closure38_iters_closure39(it: rt.Range, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$Range_u8_iters_closure131_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -4598,7 +4838,7 @@ export function turns$Range_u8_iters_closure34_iters_closure35(it: rt.Range, 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$Range_u8_u8_iters_closure126_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 { 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 => { @@ -4678,7 +4918,7 @@ export function turns$Range_u8_u8_iters_closure120_iters_closure121(it: rt.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$Range_u8_u8_iters_closure122_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$Range_u8_u8_iters_closure128_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 { 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 => { @@ -4758,7 +4998,7 @@ export function turns$Range_u8_u8_iters_closure122_iters_closure123(it: rt.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$Rev_Iter_u8_iters_closure70_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$Rev_Iter_u8_iters_closure76_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -4838,7 +5078,7 @@ export function turns$Rev_Iter_u8_iters_closure70_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$SkipWhile_Iter_u8_iters_closure93_iters_closure94_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -4918,7 +5158,7 @@ export function turns$SkipWhile_Iter_u8_iters_closure87_iters_closure88_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$Skip_Iter_u8_iters_closure71_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$Skip_Iter_u8_iters_closure77_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -4998,7 +5238,7 @@ export function turns$Skip_Iter_u8_iters_closure71_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { +export function turns$Split_char_iters_closure57_iters_closure58(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { let first!: boolean; let item!: string | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5078,7 +5318,7 @@ export function turns$Split_char_iters_closure51_iters_closure52(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { +export function turns$Split_iters_closure61_iters_closure62_iters_closure63(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { let first!: boolean; let item!: string | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5158,7 +5398,7 @@ export function turns$Split_iters_closure55_iters_closure56_iters_closure57(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$Split_str_iters_closure53_iters_closure54(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { +export function turns$Split_str_iters_closure59_iters_closure60(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { let first!: boolean; let item!: string | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5238,7 +5478,7 @@ export function turns$Split_str_iters_closure53_iters_closure54(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$StepBy_Iter_u8_iters_closure79_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5400,7 +5640,7 @@ export function turns$Successors_Logged_owned_closure15_owned_closure16_owned_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$Successors_u8_iters_closure102_iters_closure103_iters_closure104(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$Successors_u8_iters_closure108_iters_closure109_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 { let first!: boolean; let item3!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5480,7 +5720,7 @@ export function turns$Successors_u8_iters_closure102_iters_closure103_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$SymmetricDifference_u8_iters_closure131_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$SymmetricDifference_u8_iters_closure137_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5560,7 +5800,7 @@ export function turns$SymmetricDifference_u8_iters_closure131_iters_closure0(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$TakeWhile_Iter_u8_iters_closure89_iters_closure90_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$TakeWhile_Iter_u8_iters_closure95_iters_closure96_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5640,7 +5880,7 @@ export function turns$TakeWhile_Iter_u8_iters_closure89_iters_closure90_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$Take_Iter_u8_iters_closure72_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$Take_Iter_u8_iters_closure78_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5720,7 +5960,7 @@ export function turns$Take_Iter_u8_iters_closure72_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$Union_u8_iters_closure132_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5800,7 +6040,7 @@ export function turns$Union_u8_iters_closure126_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$Values_u8_u8_iters_closure125_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 { let first!: boolean; let item!: rt.u8 | undefined; const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { @@ -5960,7 +6200,7 @@ export function turns$Windows_u8_iters_closure22_iters_closure23(it: rt.Iter, 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$Zip_Countdown_Iter_u8_iters_closure103_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 { 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 => { @@ -6040,7 +6280,7 @@ export function turns$Zip_Countdown_Iter_u8_iters_closure97_iters_closure98(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$Zip_Filter_Iter_u8_iters_closure4_Filter_Iter_u8_iters_closure5_iters_closure107_iters_closure108(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$Zip_Filter_Iter_u8_iters_closure4_Filter_Iter_u8_iters_closure5_iters_closure113_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 { 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 => { @@ -6120,7 +6360,7 @@ export function turns$Zip_Filter_Iter_u8_iters_closure4_Filter_Iter_u8_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$Zip_Iter_u8_Iter_u8_iters_closure105_iters_closure106(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$Zip_Iter_u8_Iter_u8_iters_closure111_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 { 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 => { @@ -6200,7 +6440,7 @@ export function turns$Zip_Iter_u8_Iter_u8_iters_closure105_iters_closure106(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$Zip_Iter_u8_Iter_u8_iters_closure109_iters_closure110(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$Zip_Iter_u8_Iter_u8_iters_closure115_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 { 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 => { @@ -6280,7 +6520,7 @@ export function turns$Zip_Iter_u8_Iter_u8_iters_closure109_iters_closure110(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$Zip_Iter_u8_RangeInclusive_u8_iters_closure111_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$Zip_Iter_u8_RangeInclusive_u8_iters_closure117_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 { 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 => { @@ -6360,8 +6600,8 @@ export function turns$Zip_Iter_u8_RangeInclusive_u8_iters_closure111_iters_closu * clone. */ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _247!: [rt.ByteSlice, rt.ByteSlice]; - let _253!: rt.usize; + let _263!: [rt.ByteSlice, rt.ByteSlice]; + let _269!: rt.usize; let it!: rt.Peekable; const plan: Plan.Plan = { data, at: kind as rt.usize }; const n: rt.usize = mapOr$1surhce(rt.byteSliceFirst(data), 1, (_2: rt.u8): rt.u8 => { @@ -6369,15 +6609,15 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }) as rt.usize; const _9: rt.u8 = rt.u8Rem(kind, 16); if (_9 === 0) { - turns$Iter_u8_iters_closure17_iters_closure0(rt.iterSlice(rt.byteSliceView(data)), (it72: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it72.nextBack()); - }, plan, (x66: rt.u8): rt.u8 => { - return x66; + turns$Iter_u8_iters_closure17_iters_closure0(rt.iterSlice(rt.byteSliceView(data)), (it75: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it75.nextBack()); + }, plan, (x68: rt.u8): rt.u8 => { + return x68; }, out); - turns$IntoIter_u8_iters_closure18_iters_closure19(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), (it73: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it73.nextBack()); - }, plan, (x67: rt.u8): rt.u8 => { - return x67; + turns$IntoIter_u8_iters_closure18_iters_closure19(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), (it76: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it76.nextBack()); + }, plan, (x69: rt.u8): rt.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)), "index"); @@ -6388,52 +6628,52 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } _25[0].v = _25[1]; } - turns$IntoIter_u8_iters_closure20_iters_closure21(rt.iterSlice(array), (it74: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it74.nextBack()); - }, plan, (x68: rt.u8): rt.u8 => { - return x68; + turns$IntoIter_u8_iters_closure20_iters_closure21(rt.iterSlice(array), (it77: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it77.nextBack()); + }, plan, (x70: rt.u8): rt.u8 => { + return x70; }, out); } else if (_9 === 1) { - turns$Windows_u8_iters_closure22_iters_closure23(rt.byteSliceWindows(data, n), (it66: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it66.nextBack()); + turns$Windows_u8_iters_closure22_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 _326: rt.u8 = w.data[w.start]; - const _810: rt.usize = rt.usizeSub(w.length, 1); - rt.idx(w, _810); - return _326 ^ w.data[w.start + _810]; - }, out); - turns$Chunks_u8_iters_closure24_iters_closure25(rt.byteSliceChunks(data, n), (it67: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it67.nextBack()); - }, plan, (c6: rt.ByteSlice): rt.u8 => { - rt.idx(c6, 0); - return c6.data[c6.start] ^ (c6.length & 0xff); + const _322: rt.u8 = w.data[w.start]; + const _811: rt.usize = rt.usizeSub(w.length, 1); + rt.idx(w, _811); + return _322 ^ w.data[w.start + _811]; }, out); - turns$ChunksExact_u8_iters_closure26_iters_closure27(rt.byteSliceChunksExact(data, n), (it68: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it68.nextBack()); + turns$Chunks_u8_iters_closure24_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); - return c7.data[c7.start]; + return c7.data[c7.start] ^ (c7.length & 0xff); }, out); - turns$RChunks_u8_iters_closure28_iters_closure29(rt.byteSliceRchunks(data, n), (it69: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it69.nextBack()); + turns$ChunksExact_u8_iters_closure26_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); - return c8.data[c8.start] ^ (c8.length & 0xff); + return c8.data[c8.start]; }, out); - turns$RChunksExact_u8_iters_closure30_iters_closure31(rt.byteSliceRchunksExact(data, n), (it70: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it70.nextBack()); + turns$RChunks_u8_iters_closure28_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); - return c9.data[c9.start]; + return c9.data[c9.start] ^ (c9.length & 0xff); }, out); - turns$Iter_u8s_iters_closure32_iters_closure33(rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c10: rt.ByteSlice): Uint8Array => { + turns$RChunksExact_u8_iters_closure30_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); - const _330: rt.u8 = c10.data[c10.start]; - rt.idx(c10, 1); - return Uint8Array.of(_330, c10.data[c10.start + 1]); - }), undefined, 2, true)), rt.byteSliceFrom), (it71: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it71.nextBack()); + return c10.data[c10.start]; + }, out); + turns$Iter_u8s_iters_closure32_iters_closure33(rt.iterLend(rt.iterSlice(rt.iterToArray(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); + return Uint8Array.of(_328, c11.data[c11.start + 1]); + }), undefined, 2, true)), rt.byteSliceFrom), (it74: rt.Iter): rt.ByteSlice | undefined => { + return rt.iterToOption(it74.nextBack()); }, plan, (a6: rt.ByteSlice): rt.u8 => { return a6.data[a6.start] ^ a6.data[a6.start + 1]; }, out); @@ -6455,56 +6695,71 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, plan, (x61: rt.u64): rt.u8 => { return rt.u64Low(x61) & 0xff; }, out); - turns$IntoIter_u8_iters_closure40_iters_closure0(rt.iterOption(rt.byteSliceFirst(data)), (it62: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it62.nextBack()); + turns$RangeFrom_u8_iters_closure40_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 => { return x62; }, out); - turns$IntoIter_u8_iters_closure41_iters_closure42(rt.iterOption(rt.byteSliceFirst(data)), (it63: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it63.nextBack()); - }, plan, (x63: rt.u8): rt.u8 => { - return x63; + turns$RangeFrom_u64_iters_closure42_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); }, out); - turns$Once_u8_iters_closure43_iters_closure44(rt.iterOnce(n & 0xff), (it64: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it64.nextBack()); + turns$RangeFrom_char_iters_closure44_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 => { + return c6 & 0xff; + }, out); + turns$IntoIter_u8_iters_closure46_iters_closure0(rt.iterOption(rt.byteSliceFirst(data)), (it65: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it65.nextBack()); }, plan, (x64: rt.u8): rt.u8 => { return x64; }, out); - rt.iterEmpty(); - turns$Empty_u8_iters_closure45_iters_closure46(rt.iterEmpty() as rt.Iter, (it65: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it65.nextBack()); + turns$IntoIter_u8_iters_closure47_iters_closure48(rt.iterOption(rt.byteSliceFirst(data)), (it66: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it66.nextBack()); }, plan, (x65: rt.u8): rt.u8 => { return x65; }, out); + turns$Once_u8_iters_closure49_iters_closure50(rt.iterOnce(n & 0xff), (it67: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it67.nextBack()); + }, plan, (x66: rt.u8): rt.u8 => { + return x66; + }, out); + rt.iterEmpty(); + turns$Empty_u8_iters_closure51_iters_closure52(rt.iterEmpty() as rt.Iter, (it68: rt.Iter): rt.u8 | undefined => { + return rt.iterToOption(it68.nextBack()); + }, plan, (x67: rt.u8): rt.u8 => { + return x67; + }, out); } else if (_9 === 3) { - const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_288: rt.u8): rt.char => { - const _518: rt.usize = rt.u8Rem(_288, 4) as rt.usize; + 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; if (!(_518 < 4)) { rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _518); } return [97, 233, 20013, 129408][_518]; })); - turns$Chars_iters_closure47_iters_closure48(rt.strChars(text), (it53: rt.Iter): rt.char | undefined => { + turns$Chars_iters_closure53_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; }, out); - turns$Bytes_iters_closure49_iters_closure50(rt.strBytes(text), (it54: rt.Iter): rt.u8 | undefined => { + turns$Bytes_iters_closure55_iters_closure56(rt.strBytes(text), (it54: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it54.nextBack()); }, plan, (b15: rt.u8): rt.u8 => { return b15; }, out); - turns$Split_char_iters_closure51_iters_closure52(rt.strSplit(text, "é"), (it55: rt.Iter): string | undefined => { + turns$Split_char_iters_closure57_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; }, out); - turns$Split_str_iters_closure53_iters_closure54(rt.strSplit(text, "中"), (it56: rt.Iter): string | undefined => { + turns$Split_str_iters_closure59_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; }, out); - const _119: string = text; + 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); @@ -6514,162 +6769,162 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return true; }, () => make6(captured7)); }; - turns$Split_iters_closure55_iters_closure56_iters_closure57(rt.strSplit(_119, make6(0)), (it57: rt.Iter): string | undefined => { + turns$Split_iters_closure61_iters_closure62_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; }, out); - turns$MatchIndices_chars_iters_closure58_iters_closure59(rt.strMatchIndices(text, rt.patternChars([97, 129408])), (it58: rt.Iter<[rt.usize, string]>): [rt.usize, string] | undefined => { + turns$MatchIndices_chars_iters_closure64_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, (_290: [rt.usize, string]): rt.u8 => { - return (_290[0] & 0xff) ^ (rt.stringLen(_290[1]) & 0xff); + }, plan, (_283: [rt.usize, string]): rt.u8 => { + return (_283[0] & 0xff) ^ (rt.stringLen(_283[1]) & 0xff); }, out); } else if (_9 === 4) { - turns$Map_Iter_u8_iters_closure60_iters_closure61_iters_closure62(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (x49: rt.u8): rt.u8 => { + turns$Map_Iter_u8_iters_closure66_iters_closure67_iters_closure68(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (x49: rt.u8): rt.u8 => { return x49 ^ 1; }), (it45: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it45.nextBack()); }, plan, (x50: rt.u8): rt.u8 => { return x50; }, out); - turns$Filter_Iter_u8_iters_closure63_iters_closure64_iters_closure0(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_273: rt.u8): boolean => { - return rt.u8Rem(_273, 3) !== 0; + turns$Filter_Iter_u8_iters_closure69_iters_closure70_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 => { return x52; }, out); - turns$FilterMap_Iter_u8_iters_closure65_iters_closure66_iters_closure67(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_275: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(_275, 9); + turns$FilterMap_Iter_u8_iters_closure71_iters_closure72_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 => { return x54; }, out); - turns$Enumerate_Iter_u8_iters_closure68_iters_closure69(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (it48: rt.Iter<[rt.usize, rt.u8]>): [rt.usize, rt.u8] | undefined => { + turns$Enumerate_Iter_u8_iters_closure74_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, (_276: [rt.usize, rt.u8]): rt.u8 => { - return (_276[0] & 0xff) ^ _276[1]; + }, plan, (_272: [rt.usize, rt.u8]): rt.u8 => { + return (_272[0] & 0xff) ^ _272[1]; }, out); - turns$Rev_Iter_u8_iters_closure70_iters_closure0(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (it49: rt.Iter): rt.u8 | undefined => { + turns$Rev_Iter_u8_iters_closure76_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 => { return x55; }, out); - turns$Skip_Iter_u8_iters_closure71_iters_closure0(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), n), (it50: rt.Iter): rt.u8 | undefined => { + turns$Skip_Iter_u8_iters_closure77_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 => { return x56; }, out); - turns$Take_Iter_u8_iters_closure72_iters_closure0(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), rt.usizeMul(n, 2)), (it51: rt.Iter): rt.u8 | undefined => { + turns$Take_Iter_u8_iters_closure78_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 => { return x57; }, out); - turns$StepBy_Iter_u8_iters_closure73_iters_closure0(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(data)), n), (it52: rt.Iter): rt.u8 | undefined => { + turns$StepBy_Iter_u8_iters_closure79_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 => { return x58; }, out); } else if (_9 === 5) { - turns$Copied_Iter_u8_iters_closure74_iters_closure75(rt.iterSlice(rt.byteSliceView(data)), (it37: rt.Iter): rt.u8 | undefined => { + turns$Copied_Iter_u8_iters_closure80_iters_closure81(rt.iterSlice(rt.byteSliceView(data)), (it37: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it37.nextBack()); }, plan, (x41: rt.u8): rt.u8 => { return x41; }, out); - turns$Cloned_Iter_u8_iters_closure76_iters_closure77(rt.iterCloned(rt.iterSlice(rt.byteSliceView(data))), (it38: rt.Iter): rt.u8 | undefined => { + turns$Cloned_Iter_u8_iters_closure82_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 => { return x42; }, out); - turns$Fuse_Iter_u8_iters_closure78_iters_closure0(rt.iterFuse(rt.iterSlice(rt.byteSliceView(data))), (it39: rt.Iter): rt.u8 | undefined => { + turns$Fuse_Iter_u8_iters_closure84_iters_closure0(rt.iterFuse(rt.iterSlice(rt.byteSliceView(data))), (it39: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it39.nextBack()); }, plan, (x43: rt.u8): rt.u8 => { return x43; }, out); - turns$Chain_Iter_u8_Skip_Rev_Iter_u8_iters_closure79_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 => { + turns$Chain_Iter_u8_Skip_Rev_Iter_u8_iters_closure85_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 => { return x44; }, out); - turns$Peekable_Iter_u8_iters_closure80_iters_closure0(rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))), (it41: rt.Peekable): rt.u8 | undefined => { + turns$Peekable_Iter_u8_iters_closure86_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 => { return x45; }, out); - turns$FlatMap_Chunks_u8_Iter_u8_iters_closure81_iters_closure82_iters_closure0(rt.iterFlatMap(rt.byteSliceChunks(data, n), (c2: rt.ByteSlice): rt.Iter => { + turns$FlatMap_Chunks_u8_Iter_u8_iters_closure87_iters_closure88_iters_closure0(rt.iterFlatMap(rt.byteSliceChunks(data, n), (c2: rt.ByteSlice): rt.Iter => { return rt.iterSlice(rt.byteSliceView(c2)); }), (it42: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it42.nextBack()); }, plan, (x46: rt.u8): rt.u8 => { return x46; }, out); - turns$Flatten_Map_Chunks_u8_iters_closure83_iters_closure84_iters_closure85(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { + turns$Flatten_Map_Chunks_u8_iters_closure89_iters_closure90_iters_closure91(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { return rt.byteSliceToByteVec(c3); }), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value))), (it43: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it43.nextBack()); }, plan, (x47: rt.u8): rt.u8 => { return x47; }, out); - turns$Flatten_Chunks_u8_iters_closure86_iters_closure0(rt.iterFlatten(rt.byteSliceChunks(data, n), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), (it44: rt.Iter): rt.u8 | undefined => { + turns$Flatten_Chunks_u8_iters_closure92_iters_closure0(rt.iterFlatten(rt.byteSliceChunks(data, n), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), (it44: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it44.nextBack()); }, plan, (x48: rt.u8): rt.u8 => { return x48; }, out); } else if (_9 === 6) { - turns$SkipWhile_Iter_u8_iters_closure87_iters_closure88_iters_closure0(rt.iterSkipWhile(rt.iterSlice(rt.byteSliceView(data)), (_256: rt.u8): boolean => { - return rt.u8Rem(_256, 4) !== 0; + turns$SkipWhile_Iter_u8_iters_closure93_iters_closure94_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 => { return x31; }, out); - turns$TakeWhile_Iter_u8_iters_closure89_iters_closure90_iters_closure0(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_257: rt.u8): boolean => { - return rt.u8Rem(_257, 5) !== 0; + turns$TakeWhile_Iter_u8_iters_closure95_iters_closure96_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 => { return x33; }, out); - turns$MapWhile_Iter_u8_iters_closure91_iters_closure92_iters_closure93(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_267: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(_267, 3); + turns$MapWhile_Iter_u8_iters_closure97_iters_closure98_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 => { return x35; }, out); - turns$Map_Countdown_iters_closure94_iters_closure95_iters_closure96(rt.iterMap(rt.iterFrom({ _0: rt.u8Mul(n & 0xff, 3) }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (x36: rt.u8): rt.u8 => { + turns$Map_Countdown_iters_closure100_iters_closure101_iters_closure102(rt.iterMap(rt.iterFrom({ _0: rt.u8Mul(n & 0xff, 3) }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (x36: rt.u8): rt.u8 => { return x36 ^ 7; }), (it33: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it33.next()); }, plan, (x37: rt.u8): rt.u8 => { return x37; }, out); - const _220: Countdown.Countdown = { _0: rt.u8Mul(n & 0xff, 3) }; - const _224: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - turns$Zip_Countdown_Iter_u8_iters_closure97_iters_closure98(rt.iterZip(rt.iterFrom(_220, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), _224), (it34: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + const _236: Countdown.Countdown = { _0: rt.u8Mul(n & 0xff, 3) }; + const _240: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + turns$Zip_Countdown_Iter_u8_iters_closure103_iters_closure104(rt.iterZip(rt.iterFrom(_236, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), _240), (it34: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { return rt.iterToOption(it34.next()); - }, plan, (_269: [rt.u8, rt.u8]): rt.u8 => { - return _269[0] ^ _269[1]; + }, plan, (_261: [rt.u8, rt.u8]): rt.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 _270: rt.usize | undefined = rt.usizeCheckedSub(captured6, 1); - if (_270 !== undefined) { - captured6 = _270; + const _262: rt.usize | undefined = rt.usizeCheckedSub(captured6, 1); + if (_262 !== undefined) { + captured6 = _262; return captured6 & 0xff; } return undefined; }, () => make5(captured6)); }; - turns$FromFn_iters_closure99_iters_closure100_iters_closure101(rt.iterFromFn(make5(left)), (it35: rt.Iter): rt.u8 | undefined => { + turns$FromFn_iters_closure105_iters_closure106_iters_closure107(rt.iterFromFn(make5(left)), (it35: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it35.next()); }, plan, (x38: rt.u8): rt.u8 => { return x38; }, out); - turns$Successors_u8_iters_closure102_iters_closure103_iters_closure104(rt.iterSuccessors(rt.u8Mul(n & 0xff, 40), (_272: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(_272, 17); + turns$Successors_u8_iters_closure108_iters_closure109_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 => { @@ -6681,69 +6936,69 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.panic("mid > len"); } if (!((kind & 32) === 0)) { - _247 = [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 rt.ByteSlice(data.data, data.start + mid, data.length - mid), new rt.ByteSlice(data.data, data.start, mid)] as [rt.ByteSlice, rt.ByteSlice]; } else { - _247 = [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 rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid, data.length - mid)] as [rt.ByteSlice, rt.ByteSlice]; } - const a2: rt.ByteSlice = _247[0]; - const b3: rt.ByteSlice = _247[1]; + const a2: rt.ByteSlice = _263[0]; + const b3: rt.ByteSlice = _263[1]; let iterStart: rt.usize = 0; const iterEnd: rt.usize = 2; - while ((_253 = iterStart++) < iterEnd) { - const skip: rt.usize = _253; + 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)), "index"); - const _262: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), skip); + const _278: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), skip); let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = _262; + const iterEnd2: rt.usize = _278; while (iterStart2++ < iterEnd2) { zip.next(); } - turns$Zip_Iter_u8_Iter_u8_iters_closure105_iters_closure106(zip, (it26: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + turns$Zip_Iter_u8_Iter_u8_iters_closure111_iters_closure112(zip, (it26: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { return rt.iterToOption(it26.nextBack()); - }, plan, (_242: [rt.u8, rt.u8]): rt.u8 => { - return _242[0] ^ _242[1]; + }, plan, (_234: [rt.u8, rt.u8]): rt.u8 => { + return _234[0] ^ _234[1]; }, out); - const zip2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFilter(rt.iterSlice(rt.byteSliceView(a2)), (_243: rt.u8): boolean => { + const zip2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFilter(rt.iterSlice(rt.byteSliceView(a2)), (_241: rt.u8): boolean => { return true; - }), rt.iterFilter(rt.iterSlice(rt.byteSliceView(b3)), (_245: rt.u8): boolean => { + }), rt.iterFilter(rt.iterSlice(rt.byteSliceView(b3)), (_242: rt.u8): boolean => { return true; })); - const _283: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), skip); + const _299: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), skip); let iterStart3: rt.usize = 0; - const iterEnd3: rt.usize = _283; + const iterEnd3: rt.usize = _299; while (iterStart3++ < iterEnd3) { zip2.next(); } - turns$Zip_Filter_Iter_u8_iters_closure4_Filter_Iter_u8_iters_closure5_iters_closure107_iters_closure108(zip2, (it27: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + turns$Zip_Filter_Iter_u8_iters_closure4_Filter_Iter_u8_iters_closure5_iters_closure113_iters_closure114(zip2, (it27: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { return rt.iterToOption(it27.next()); - }, plan, (_246: [rt.u8, rt.u8]): rt.u8 => { - return _246[0] ^ _246[1]; + }, plan, (_244: [rt.u8, rt.u8]): rt.u8 => { + return _244[0] ^ _244[1]; }, out); } - turns$Zip_Iter_u8_Iter_u8_iters_closure109_iters_closure110(rt.iterZip(rt.iterSlice(rt.byteSliceView(a2)), rt.iterSlice(rt.byteSliceView(b3)), "index"), (it28: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + turns$Zip_Iter_u8_Iter_u8_iters_closure115_iters_closure116(rt.iterZip(rt.iterSlice(rt.byteSliceView(a2)), rt.iterSlice(rt.byteSliceView(b3)), "index"), (it28: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { return rt.iterToOption(it28.nextBack()); - }, plan, (_252: [rt.u8, rt.u8]): rt.u8 => { - return _252[0] ^ _252[1]; + }, plan, (_247: [rt.u8, rt.u8]): rt.u8 => { + return _247[0] ^ _247[1]; }, out); - turns$Zip_Iter_u8_RangeInclusive_u8_iters_closure111_iters_closure112(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 => { + turns$Zip_Iter_u8_RangeInclusive_u8_iters_closure117_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, (_254: [rt.u8, rt.u8]): rt.u8 => { - return _254[0] ^ _254[1]; + }, plan, (_248: [rt.u8, rt.u8]): rt.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)), (_255: rt.u8): rt.u8 => { - const x28: rt.u8 = _255; + 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); return x28; }); - const _314: rt.Iter = zip3; - const _316: rt.Iter = rt.iterSlice(rt.byteSliceView(b3)); - const zip22: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterBorrow(_314), _316, "len"); - const _319: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), 1); + 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 = _319; + const iterEnd4: rt.usize = _335; while (iterStart4++ < iterEnd4) { zip22.next(); } @@ -6756,15 +7011,15 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let iterStart5: rt.usize = 0; const iterEnd5: rt.usize = n; while (iterStart5++ < iterEnd5) { - rt.byteVecPush(out, mapOr$1surhce(rt.peekablePeek(it), 238, (_238: rt.u8): rt.u8 => { - return _238; + rt.byteVecPush(out, mapOr$1surhce(rt.peekablePeek(it), 238, (_227: rt.u8): rt.u8 => { + return _227; })); it.next(); } - rt.byteVecPush(out, mapOr$1surhce(rt.peekablePeek(it), 238, (_239: rt.u8): rt.u8 => { - return _239; + rt.byteVecPush(out, mapOr$1surhce(rt.peekablePeek(it), 238, (_233: rt.u8): rt.u8 => { + return _233; })); - turns$Peekable_Iter_u8_iters_closure113_iters_closure0(it, (it24: rt.Peekable): rt.u8 | undefined => { + turns$Peekable_Iter_u8_iters_closure119_iters_closure0(it, (it24: rt.Peekable): rt.u8 | undefined => { return rt.iterToOption(it24.nextBack()); }, plan, (x26: rt.u8): rt.u8 => { return x26; @@ -6774,117 +7029,117 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, rt.peekablePeek(it2) !== undefined ? 1 : 0); rt.byteVecPush(out, rt.peekablePeek(it2.clone()) !== undefined ? 1 : 0); - turns$Peekable_Copied_Iter_u8_iters_closure114_iters_closure115(it2, (it25: rt.Peekable): rt.u8 | undefined => { + turns$Peekable_Copied_Iter_u8_iters_closure120_iters_closure121(it2, (it25: rt.Peekable): rt.u8 | undefined => { return rt.iterToOption(it25.nextBack()); }, plan, (x27: rt.u8): rt.u8 => { return x27; }, out); } else if (_9 === 9) { - const _387: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_225: rt.u8): [rt.u8, rt.u8] => { - const b12: rt.u8 = _225; + 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 map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _387, true, undefined, undefined, undefined, 2, true); - const _390: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): rt.u8 => { - return rt.u8Rem(_226, 32); + 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 set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _390, true, undefined, undefined, 1, true); + 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(unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 32); - turns$Iter_u8_u8_iters_closure116_iters_closure117(rt.btreeIter(map), (it17: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + turns$Iter_u8_u8_iters_closure122_iters_closure123(rt.btreeIter(map), (it17: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { return rt.iterToOption(it17.nextBack()); - }, plan, (_228: [rt.u8, rt.u8]): rt.u8 => { - return _228[0] ^ _228[1]; + }, plan, (_222: [rt.u8, rt.u8]): rt.u8 => { + return _222[0] ^ _222[1]; }, out); - turns$Keys_u8_u8_iters_closure118_iters_closure0(rt.btreeKeys(map), (it18: rt.Iter): rt.u8 | undefined => { + turns$Keys_u8_u8_iters_closure124_iters_closure0(rt.btreeKeys(map), (it18: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it18.nextBack()); }, plan, (x20: rt.u8): rt.u8 => { return x20; }, out); - turns$Values_u8_u8_iters_closure119_iters_closure0(rt.btreeValues(map), (it19: rt.Iter): rt.u8 | undefined => { + turns$Values_u8_u8_iters_closure125_iters_closure0(rt.btreeValues(map), (it19: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it19.nextBack()); }, plan, (x21: rt.u8): rt.u8 => { return x21; }, out); - turns$Range_u8_u8_iters_closure120_iters_closure121(rt.btreeRange(map, { start: lo2 }), (it20: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + turns$Range_u8_u8_iters_closure126_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, (_231: [rt.u8, rt.u8]): rt.u8 => { - return _231[0] ^ _231[1]; + }, plan, (_223: [rt.u8, rt.u8]): rt.u8 => { + return _223[0] ^ _223[1]; }, out); - turns$Range_u8_u8_iters_closure122_iters_closure123(rt.btreeRange(map, { end: lo2, inclusive: true }), (it21: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { + turns$Range_u8_u8_iters_closure128_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, (_232: [rt.u8, rt.u8]): rt.u8 => { - return _232[0] ^ _232[1]; + }, plan, (_226: [rt.u8, rt.u8]): rt.u8 => { + return _226[0] ^ _226[1]; }, out); - turns$Iter_u8_iters_closure124_iters_closure0(rt.btreeKeys(set), (it22: rt.Iter): rt.u8 | undefined => { + turns$Iter_u8_iters_closure130_iters_closure0(rt.btreeKeys(set), (it22: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it22.nextBack()); }, plan, (x22: rt.u8): rt.u8 => { return x22; }, out); - turns$Range_u8_iters_closure125_iters_closure0(rt.btreeRangeKeys(set, { start: lo2 }), (it23: rt.Iter): rt.u8 | undefined => { + turns$Range_u8_iters_closure131_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 => { return x23; }, out); } else if (_9 === 10) { - const _429: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): [rt.u8, rt.u8] => { + 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 map2: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _429, undefined, undefined, undefined, 469762048); - const _432: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_217: rt.u8): rt.u8 => { - return rt.u8Rem(_217, 32); + 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 set2: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _432, undefined, undefined, 469762048); - unordered$Map_Iter_u8_u8_iters_closure14(rt.iterMap(rt.hashIter(map2), (_218: [rt.u8, rt.u8]): rt.u8 => { - return _218[0] ^ _218[1]; + const set2: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _448, undefined, undefined, 469762048); + unordered$Map_Iter_u8_u8_iters_closure14(rt.iterMap(rt.hashIter(map2), (_215: [rt.u8, rt.u8]): rt.u8 => { + return _215[0] ^ _215[1]; }), plan, out); unordered$Copied_Keys_u8_u8(rt.hashKeys(map2), plan, out); unordered$Copied_Values_u8_u8(rt.hashValues(map2), plan, out); unordered$Copied_Iter_u8(rt.hashKeys(set2), plan, out); } else if (_9 === 11) { const split2: rt.usize = rt.usizeRem(unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, rt.usizeAdd(data.length, 1)); - const _464: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, split2))), (_29: rt.u8): rt.u8 => { + 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 a3: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _464, true, undefined, undefined, 1, true); - const _469: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, split2))), (_210: rt.u8): rt.u8 => { + 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 b4: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _469, true, undefined, undefined, 1, true); - turns$Union_u8_iters_closure126_iters_closure0(rt.btreeUnion(a3, b4), (it11: rt.Iter): rt.u8 | undefined => { + const b4: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _485, true, undefined, undefined, 1, true); + turns$Union_u8_iters_closure132_iters_closure0(rt.btreeUnion(a3, b4), (it11: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it11.next()); }, plan, (x14: rt.u8): rt.u8 => { return x14; }, out); - turns$Intersection_u8_iters_closure127_iters_closure0(rt.btreeIntersection(a3, b4), (it12: rt.Iter): rt.u8 | undefined => { + turns$Intersection_u8_iters_closure133_iters_closure0(rt.btreeIntersection(a3, b4), (it12: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it12.next()); }, plan, (x15: rt.u8): rt.u8 => { return x15; }, out); - turns$Intersection_u8_iters_closure128_iters_closure0(rt.btreeIntersection(b4, a3), (it13: rt.Iter): rt.u8 | undefined => { + turns$Intersection_u8_iters_closure134_iters_closure0(rt.btreeIntersection(b4, a3), (it13: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it13.next()); }, plan, (x16: rt.u8): rt.u8 => { return x16; }, out); - turns$Difference_u8_iters_closure129_iters_closure0(rt.btreeDifference(a3, b4), (it14: rt.Iter): rt.u8 | undefined => { + turns$Difference_u8_iters_closure135_iters_closure0(rt.btreeDifference(a3, b4), (it14: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it14.next()); }, plan, (x17: rt.u8): rt.u8 => { return x17; }, out); - turns$Difference_u8_iters_closure130_iters_closure0(rt.btreeDifference(b4, a3), (it15: rt.Iter): rt.u8 | undefined => { + turns$Difference_u8_iters_closure136_iters_closure0(rt.btreeDifference(b4, a3), (it15: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it15.next()); }, plan, (x18: rt.u8): rt.u8 => { return x18; }, out); - turns$SymmetricDifference_u8_iters_closure131_iters_closure0(rt.btreeSymmetricDifference(a3, b4), (it16: rt.Iter): rt.u8 | undefined => { + turns$SymmetricDifference_u8_iters_closure137_iters_closure0(rt.btreeSymmetricDifference(a3, b4), (it16: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it16.next()); }, plan, (x19: rt.u8): rt.u8 => { return x19; }, out); - const _504: rt.Iter = rt.btreeKeys(a3); - const a4: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _504, undefined, undefined, 469762048); - const _506: rt.Iter = rt.btreeKeys(b4); - const b5: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _506, undefined, undefined, 469762048); + 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$Copied_Union_u8_RandomState(rt.hashUnion(a4, b5), plan, out); unordered$Copied_Intersection_u8_RandomState(rt.hashIntersection(a4, b5), plan, out); unordered$Copied_Difference_u8_RandomState(rt.hashDifference(a4, b5), plan, out); @@ -6898,23 +7153,23 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.dequePushBack(q, b6); } } - turns$Iter_u8_iters_closure132_iters_closure0(rt.dequeIter(q), (it7: rt.Iter): rt.u8 | undefined => { + turns$Iter_u8_iters_closure138_iters_closure0(rt.dequeIter(q), (it7: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it7.nextBack()); }, plan, (x10: rt.u8): rt.u8 => { return x10; }, out); - turns$IntoIter_u8_iters_closure133_iters_closure134(rt.dequeIter(rt.dequeClone(q, undefined)), (it8: rt.Iter): rt.u8 | undefined => { + turns$IntoIter_u8_iters_closure139_iters_closure140(rt.dequeIter(rt.dequeClone(q, undefined)), (it8: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it8.nextBack()); }, plan, (x11: rt.u8): rt.u8 => { return x11; }, out); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); - turns$Iter_u8_iters_closure135_iters_closure0(rt.heapIter(heap), (it9: rt.Iter): rt.u8 | undefined => { + turns$Iter_u8_iters_closure141_iters_closure0(rt.heapIter(heap), (it9: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it9.nextBack()); }, plan, (x12: rt.u8): rt.u8 => { return x12; }, out); - turns$IntoIter_u8_iters_closure136_iters_closure137(rt.heapIter(heap), (it10: rt.Iter): rt.u8 | undefined => { + turns$IntoIter_u8_iters_closure142_iters_closure143(rt.heapIter(heap), (it10: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it10.nextBack()); }, plan, (x13: rt.u8): rt.u8 => { return x13; @@ -6924,7 +7179,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_9 === 14) { closures(data, plan, out); } else { - const _566: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + 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; @@ -6932,13 +7187,13 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x ^ captured; }, () => make(captured)); }; - turns$Map_Iter_u8_iters_closure138_iters_closure139_iters_closure140(rt.iterMap(_566, make(0)), (it3: rt.Iter): rt.u8 | undefined => { + turns$Map_Iter_u8_iters_closure144_iters_closure145_iters_closure146(rt.iterMap(_582, make(0)), (it3: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it3.nextBack()); }, plan, (x2: rt.u8): rt.u8 => { return x2; }, out); const seen: rt.ByteVec = new rt.ByteVec(); - const _572: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + 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); @@ -6947,25 +7202,25 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.byteVecFrom(rt.byteVecView(a0)); })(captured2))); }; - turns$Filter_Iter_u8_iters_closure141_iters_closure142_iters_closure0(rt.iterFilter(_572, make2(seen)), (it4: rt.Iter): rt.u8 | undefined => { + turns$Filter_Iter_u8_iters_closure147_iters_closure148_iters_closure0(rt.iterFilter(_588, make2(seen)), (it4: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it4.nextBack()); }, plan, (x4: rt.u8): rt.u8 => { return x4; }, out); - const _578: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + 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); }, () => make3(captured3)); }; - turns$Map_Inspect_Iter_u8_iters_closure143_iters_closure144_iters_closure145_iters_closure146(rt.iterMap(rt.iterInspect(_578, make3(0)), (_28: rt.u8): rt.u8 => { + turns$Map_Inspect_Iter_u8_iters_closure149_iters_closure150_iters_closure151_iters_closure152(rt.iterMap(rt.iterInspect(_594, make3(0)), (_28: rt.u8): rt.u8 => { return _28; }), (it5: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it5.next()); }, plan, (x7: rt.u8): rt.u8 => { return x7; }, out); - const _583: rt.Iter = rt.byteSliceChunks(data, n); + 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); @@ -6976,7 +7231,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); }, () => make4(captured4)); }; - turns$FlatMap_Chunks_u8_Map_Iter_u8_iters_closure147_closure0_iters_closure147_iters_closure148_iters_closure149(rt.iterFlatMap(_583, make4(0)), (it6: rt.Iter): rt.u8 | undefined => { + turns$FlatMap_Chunks_u8_Map_Iter_u8_iters_closure153_closure0_iters_closure153_iters_closure154_iters_closure155(rt.iterFlatMap(_599, make4(0)), (it6: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it6.nextBack()); }, plan, (x9: rt.u8): rt.u8 => { return x9; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index ea380d65d..383b88a07 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -9,6 +9,7 @@ import { captures } from "./captures.ts"; import { cells } from "./cells.ts"; import { chars } from "./chars.ts"; import { chunks } from "./chunks.ts"; +import { iters } from "./clones.ts"; import { hashMaps, sets, btreeMaps, deques, vecs, stores, optionals, setOps, unlikeEqs, ownNes } from "./collections.ts"; import { combinators } from "./combinators.ts"; import { arcs, clonedArcs, cyclicArcs, uniqueArcs, clonedRcs, cyclicRcs, rcs, uniqueRcs, copies } from "./counts.ts"; @@ -19,7 +20,7 @@ import { dyns, shared, anys, fns } from "./dyns.ts"; import { edits, bytes } from "./edits.ts"; import { eqs } from "./errors.ts"; import { floats, mulAdds, formats, parses } from "./floats.ts"; -import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, iters, writes } from "./fmt.ts"; +import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, iters as fmt_iters, writes } from "./fmt.ts"; import { folds } from "./folds.ts"; import { methods } from "./generics.ts"; import { values, random, bytes as hashes_bytes } from "./hashes.ts"; @@ -195,8 +196,8 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) }] 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], ["singles::mul_adds", singles_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { collections(data71, out72); }] 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], ["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", zeros_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::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], ["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], ["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], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { - iters(data72, out73); - }] 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], ["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]]; + fmt_iters(data72, out73); + }] 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], ["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], ["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]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/src/clones.rs b/ts/fixtures/lang/src/clones.rs index 3dec52d0d..fbb1d7710 100644 --- a/ts/fixtures/lang/src/clones.rs +++ b/ts/fixtures/lang/src/clones.rs @@ -173,6 +173,10 @@ pub fn iters(kind: u8, data: &[u8], out: &mut Vec) { both!(lo..hi, |x| x); both!(lo..=hi, |x| x); both!(u64::from(lo)..u64::from(hi), |x| x as u8); + // `start..`, which never ends: bounded by `turns`' reads, short of `u8::MAX`. + front!(lo.., |x| x); + front!(u64::from(lo) << 53.., |x| (x >> 50) as u8 ^ x as u8); + front!(char::from(b'a' + lo).., |c| c as u8); both!(data.first().into_iter(), id); both!(data.first().copied().into_iter(), |x| x); both!(std::iter::once(n as u8), |x| x); diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 7b420916b..a166f3ee7 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -866,7 +866,7 @@ fn clones<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option< ] | ["str", "iter", "Chars" | "Bytes"] | ["option", "Iter"] - | ["ops", "range", "Range" | "RangeInclusive"] + | ["ops", "range", "Range" | "RangeFrom" | "RangeInclusive"] | ["collections", "vec_deque", "iter", "Iter"] | ["collections", "binary_heap", "Iter"] | ["collections", "btree", "map", "Iter" | "Keys" | "Values" | "Range"]