From 33488ce38b452802146f96a91bc0314ffb3908ba Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 16:03:14 -0700 Subject: [PATCH 1/5] chore(quest): claim quest/m3/ts-array-keys.md Quest-Claim: 721692e74d14e1ba From 95b604ac4a429457c1a84aab482432df1a55d306 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 16:33:46 -0700 Subject: [PATCH 2/5] feat(ts): translate collections of array keys, found by the slices they borrow as Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/core/bool.ts | 57 + ts/fixtures/lang/expected/core/option.ts | 114 +- ts/fixtures/lang/expected/harness.ts | 4 +- ts/fixtures/lang/expected/hints.Big.ts | 31 - ts/fixtures/lang/expected/hints.ts | 764 ++++---- ts/fixtures/lang/expected/keys.ts | 2178 +++++++++++++++++++++- ts/fixtures/lang/expected/lib.ts | 38 +- ts/fixtures/lang/src/harness.rs | 1 + ts/fixtures/lang/src/hints.rs | 7 +- ts/fixtures/lang/src/keys.rs | 126 ++ ts/runtime/rt/collections.ts | 19 +- ts/src/lower/collections.rs | 6 +- 12 files changed, 2905 insertions(+), 440 deletions(-) delete mode 100644 ts/fixtures/lang/expected/hints.Big.ts diff --git a/ts/fixtures/lang/expected/core/bool.ts b/ts/fixtures/lang/expected/core/bool.ts index 42e4be89f..7b7c84928 100644 --- a/ts/fixtures/lang/expected/core/bool.ts +++ b/ts/fixtures/lang/expected/core/bool.ts @@ -2,6 +2,7 @@ import * as rt from "../rt.ts"; import * as Made from "../defaults.Made.ts"; +import type * as Hop from "../keys.Hop.ts"; import type * as Way from "../keys.Way.ts"; import type * as Void from "../shapes.Void.ts"; @@ -124,6 +125,13 @@ export function then$1j955kq(self: boolean, _: () => Made.Made): Made.Made | und return Made.default$Default(); } +export function then$1c9ust9(self: boolean, f: () => Hop.Hop[]): Hop.Hop[] | undefined { + if (!self) { + return undefined; + } + return f(); +} + export function then$1t2ieki(self: boolean, f: () => [rt.u64 | undefined, Made.Made]): [rt.u64 | undefined, Made.Made] | undefined { if (!self) { return undefined; @@ -138,6 +146,13 @@ export function then$16ew6vr(self: boolean, f: () => rt.u8 | undefined): rt.u8 | return f(); } +export function then$0b2eeh4(self: boolean, f: () => Array): Array | undefined { + if (!self) { + return undefined; + } + return f(); +} + export function then$0afp4no(self: boolean, f: () => rt.Result): rt.Result | undefined { if (!self) { return undefined; @@ -166,6 +181,27 @@ export function then$0ozmvid(self: boolean, f: () => rt.ByteVec): rt.ByteVec | u return f(); } +export function then$1ghn4qd(self: boolean, f: () => boolean[]): boolean[] | undefined { + if (!self) { + return undefined; + } + return f(); +} + +export function then$1dhbcvy(self: boolean, f: () => rt.char[]): rt.char[] | undefined { + if (!self) { + return undefined; + } + return f(); +} + +export function then$1nf265w(self: boolean, f: () => rt.i32[]): rt.i32[] | undefined { + if (!self) { + return undefined; + } + return f(); +} + export function then$0havnzo(self: boolean, f: () => string): string | undefined { if (!self) { return undefined; @@ -173,6 +209,27 @@ export function then$0havnzo(self: boolean, f: () => string): string | undefined return f(); } +export function then$0l07w38(self: boolean, f: () => rt.u16[]): rt.u16[] | undefined { + if (!self) { + return undefined; + } + return f(); +} + +export function then$0l8o6jo(self: boolean, f: () => rt.u32[]): rt.u32[] | undefined { + if (!self) { + return undefined; + } + return f(); +} + +export function then$0uovwq9(self: boolean, f: () => rt.u64[]): rt.u64[] | undefined { + if (!self) { + return undefined; + } + return f(); +} + export function then$1btzga3(self: boolean, f: () => rt.u8): rt.u8 | undefined { if (!self) { return undefined; diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index d413ff6f7..4ce0b7ee6 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -17,7 +17,6 @@ import type * as Twin from "../counts.Twin.ts"; import * as Made from "../defaults.Made.ts"; import type * as Shape from "../dyns.Shape.ts"; import * as Named from "../edits.Named.ts"; -import type * as Big from "../hints.Big.ts"; import type * as Unit from "../hints.Unit.ts"; import type * as Quarter from "../iters.Quarter.ts"; import type * as Tilt from "../iters.Tilt.ts"; @@ -553,6 +552,20 @@ export function mapOr$04khdaj(self: Hop.Hop | undefined, default_: rt.u64, f: (a return f(self); } +export function mapOr$0rtxftk(self: Hop.Hop[] | undefined, default_: rt.u8, f: (a0: Hop.Hop[]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0spovx0(self: [Hop.Hop[], rt.u8] | undefined, default_: rt.u8, f: (a0: [Hop.Hop[], rt.u8]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$14aggam(self: orders_Item.Item | undefined, default_: rt.u8, f: (a0: orders_Item.Item) => rt.u8): rt.u8 { if (self === undefined) { return default_; @@ -623,6 +636,20 @@ export function mapOr$1xztl8h(self: rt.u8 | undefined | rt.None, default_: rt.u8 return f(self); } +export function mapOr$1bumeih(self: Array | undefined, default_: rt.u8, f: (a0: Array) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$187k0x1(self: [Array, rt.u8] | undefined, default_: rt.u8, f: (a0: [Array, rt.u8]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { if (self === undefined) { return default_; @@ -721,28 +748,28 @@ export function mapOr$1unqgn7(self: rt.Arc[] | undefined, de return f(self); } -export function mapOr$1cxlmys(self: Big.Big[] | undefined, default_: rt.usize, f: (a0: Big.Big[]) => rt.usize): rt.usize { +export function mapOr$0r2th8w(self: Unit.Unit[] | undefined, default_: rt.usize, f: (a0: Unit.Unit[]) => rt.usize): rt.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0r2th8w(self: Unit.Unit[] | undefined, default_: rt.usize, f: (a0: Unit.Unit[]) => rt.usize): rt.usize { +export function mapOr$1kiffmd(self: rt.u16[] | undefined, default_: rt.u8, f: (a0: rt.u16[]) => rt.u8): rt.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1kiffmd(self: rt.u16[] | undefined, default_: rt.u8, f: (a0: rt.u16[]) => rt.u8): rt.u8 { +export function mapOr$1umcrqz(self: rt.u32[] | undefined, default_: rt.usize, f: (a0: rt.u32[]) => rt.usize): rt.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1umcrqz(self: rt.u32[] | undefined, default_: rt.usize, f: (a0: rt.u32[]) => rt.usize): rt.usize { +export function mapOr$0ow0wo0(self: rt.u32[][] | undefined, default_: rt.usize, f: (a0: rt.u32[][]) => rt.usize): rt.usize { if (self === undefined) { return default_; } @@ -777,6 +804,20 @@ export function mapOr$08xwngs(self: rt.ByteVec | undefined, default_: rt.usize, return f(self); } +export function mapOr$0qqhf4e(self: boolean[] | undefined, default_: rt.u8, f: (a0: boolean[]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$13q9j26(self: [boolean[], rt.u8] | undefined, default_: rt.u8, f: (a0: [boolean[], rt.u8]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$0atjiti(self: rt.char | undefined, default_: rt.u32, _: (a0: rt.char) => rt.u32): rt.u32 { if (self === undefined) { return default_; @@ -784,6 +825,34 @@ export function mapOr$0atjiti(self: rt.char | undefined, default_: rt.u32, _: (a return self as rt.u32; } +export function mapOr$141aobk(self: rt.char[] | undefined, default_: rt.u8, f: (a0: rt.char[]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$1afbbm4(self: [rt.char[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.char[], rt.u8]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$17y4wkx(self: rt.i32[] | undefined, default_: rt.u8, f: (a0: rt.i32[]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$03mkmku(self: [rt.i32[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.i32[], rt.u8]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$1llunel(self: rt.u16 | undefined, default_: rt.u16, f: (a0: rt.u16) => rt.u16): rt.u16 { if (self === undefined) { return default_; @@ -798,6 +867,13 @@ export function mapOr$099335t(self: rt.u16 | undefined, default_: rt.u8, f: (a0: return f(self); } +export function mapOr$0iyypgq(self: [rt.u16[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u16[], rt.u8]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$1giiemz(self: rt.Place | undefined, default_: rt.u32, f: (a0: rt.Place) => rt.u32): rt.u32 { if (self === undefined) { return default_; @@ -805,6 +881,20 @@ export function mapOr$1giiemz(self: rt.Place | undefined, default_: rt.u return f(self); } +export function mapOr$1h1mlmc(self: rt.u32[] | undefined, default_: rt.u8, f: (a0: rt.u32[]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$1xwgm12(self: [rt.u32[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u32[], rt.u8]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$0ucbp7g(self: [rt.u64, rt.u64] | undefined, default_: rt.u8, f: (a0: [rt.u64, rt.u64]) => rt.u8): rt.u8 { if (self === undefined) { return default_; @@ -812,6 +902,20 @@ export function mapOr$0ucbp7g(self: [rt.u64, rt.u64] | undefined, default_: rt.u return f(self); } +export function mapOr$0nlcxqx(self: rt.u64[] | undefined, default_: rt.u8, f: (a0: rt.u64[]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0vfd25u(self: [rt.u64[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u64[], rt.u8]) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$1wxcg5q(self: [rt.u8, rt.Arc] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.Arc]) => rt.u8): rt.u8 { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 96a3147b1..91fae9cce 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -27,7 +27,7 @@ import { hints, reserves } from "./hints.ts"; import { holds } from "./holds.ts"; import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast as ints_cast, convert, parses as ints_parses, widenings } from "./ints.ts"; import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, own, values as iters_values, returned } from "./iters.ts"; -import { keys, overrides, bytes as keys_bytes, lentKeys, lentValues } from "./keys.ts"; +import { keys, overrides, bytes as keys_bytes, lentKeys, lentValues, arrays } from "./keys.ts"; import { locals } from "./locals.ts"; import { locks, relock, rwlocks } from "./locks.ts"; import { nested } from "./nested.ts"; @@ -192,7 +192,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) maps(data69, out70); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::lent", (_2170: rt.u8, data70: rt.ByteSlice, out71: rt.ByteVec): undefined => { lent(data70, out71); - }] 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]]; + }] 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], ["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]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/hints.Big.ts b/ts/fixtures/lang/expected/hints.Big.ts deleted file mode 100644 index 55acb3b39..000000000 --- a/ts/fixtures/lang/expected/hints.Big.ts +++ /dev/null @@ -1,31 +0,0 @@ -// Generated by rust2-ts. Do not edit. - -import * as rt from "./rt.ts"; -import { copy$u32s } from "./lib.ts"; - -export function clone$Clone(self: Big): Big { - return { _0: copy$u32s(self._0) }; -} - -export function eq$PartialEq(self: Big, other: Big): boolean { - return rt.eqSlice(rt.same)(self._0, other._0); -} - -export function partialCmp$PartialOrd(self: Big, other: Big): rt.Ordering | undefined { - return cmp$Ord(self, other); -} - -export function cmp$Ord(self: Big, other: Big): rt.Ordering { - return rt.cmpSlice(rt.cmp)(self._0, other._0); -} - -export function hash$Hash_DefaultHasher(self: Big, state: rt.Hasher): void { - rt.hashSlice(rt.hash32)(self._0, state); -} - -/** Over 1024 bytes, which a `Vec` grows by as few as one of. */ -export interface Big { - _0: rt.u32[]; -} - -//# sourceMappingURL=hints.Big.ts.map diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index 2a3d6a76f..41d3b31af 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -1,11 +1,10 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$u64s } from "./lib.ts"; +import { copy$u32s, copy$u64s } from "./lib.ts"; import { thenSome$1ugl8af } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr, unwrapOr$1rbuegs, mapOr$1cxlmys, mapOr$0r2th8w, mapOr$1umcrqz, mapOr$0pdoq6p, mapOr$0amk6zv, mapOr$08xwngs } from "./core/option.ts"; +import { unwrapOr$0r2bmpr, unwrapOr$1rbuegs, mapOr$0r2th8w, mapOr$1umcrqz, mapOr$0ow0wo0, mapOr$0pdoq6p, mapOr$0amk6zv, mapOr$08xwngs } from "./core/option.ts"; import { unwrapOr$0u9zzk3 } from "./core/result.ts"; -import * as Big from "./hints.Big.ts"; import * as Countdown from "./hints.Countdown.ts"; import * as Endless from "./hints.Endless.ts"; import type * as Most from "./hints.Most.ts"; @@ -2170,16 +2169,16 @@ export function reserves(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void return {}; }, { vec: 4294967295, pairs: 536870911, set: 536870911, map: 234881024 }, out); } else { - typed$Big_reserves_closure5(kind, data, (i: rt.u32): Big.Big => { - return { _0: Array.from({ length: 275 }, (): rt.u32 => { + typed$u32s_reserves_closure5(kind, data, (i: rt.u32): rt.u32[] => { + return Array.from({ length: 275 }, (): rt.u32 => { return i; - }) }; + }); }, { vec: 1952257, pairs: 1945184, set: 917504, map: 917504 }, out); } } /** `reserves` of elements `make` makes. */ -export function typed$Big_reserves_closure5(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => Big.Big, most: Most.Most, out: rt.ByteVec): void { +export function typed$Unit_reserves_closure4(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => Unit.Unit, most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; @@ -2224,9 +2223,9 @@ export function typed$Big_reserves_closure5(kind: rt.u8, data: rt.ByteSlice, mak count = 4294967296; } const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); - const seed: Big.Big = make(7); + const seed: Unit.Unit = make(7); const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => Big.Big = (i2: rt.u32): Big.Big => { + const f: (a0: rt.u32) => Unit.Unit = (i2: rt.u32): Unit.Unit => { rt.cellSet(calls, rt.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { rt.panicFmt(["consumed"]); @@ -2235,23 +2234,23 @@ export function typed$Big_reserves_closure5(kind: rt.u8, data: rt.ByteSlice, mak } }; if (shape === 0) { - fill$Big_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$Unit_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); } else if (shape === 1) { - fill$Big_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$Unit_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$Big_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: Big.Big): boolean => { + fill$Unit_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: Unit.Unit): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$Unit_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); } else { - fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$Unit_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); } rt.byteVecPush(out, calls.v); } /** `reserves` of elements `make` makes. */ -export function typed$Unit_reserves_closure4(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => Unit.Unit, most: Most.Most, out: rt.ByteVec): void { +export function typed$u32_reserves_closure1(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u32, most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; @@ -2296,9 +2295,9 @@ export function typed$Unit_reserves_closure4(kind: rt.u8, data: rt.ByteSlice, ma count = 4294967296; } const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); - const seed: Unit.Unit = make(7); + const seed: rt.u32 = make(7); const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => Unit.Unit = (i2: rt.u32): Unit.Unit => { + const f: (a0: rt.u32) => rt.u32 = (i2: rt.u32): rt.u32 => { rt.cellSet(calls, rt.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { rt.panicFmt(["consumed"]); @@ -2307,23 +2306,23 @@ export function typed$Unit_reserves_closure4(kind: rt.u8, data: rt.ByteSlice, ma } }; if (shape === 0) { - fill$Unit_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$u32_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); } else if (shape === 1) { - fill$Unit_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$u32_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$Unit_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: Unit.Unit): boolean => { + fill$u32_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: rt.u32): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$Unit_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); } else { - fill$Unit_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); } rt.byteVecPush(out, calls.v); } /** `reserves` of elements `make` makes. */ -export function typed$u32_reserves_closure1(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u32, most: Most.Most, out: rt.ByteVec): void { +export function typed$u32s_reserves_closure5(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u32[], most: Most.Most, out: rt.ByteVec): void { let _20!: [rt.u64, rt.u64]; let past!: rt.u64; let count!: rt.u64; @@ -2368,9 +2367,9 @@ export function typed$u32_reserves_closure1(kind: rt.u8, data: rt.ByteSlice, mak count = 4294967296; } const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); - const seed: rt.u32 = make(7); + const seed: rt.u32[] = make(7); const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => rt.u32 = (i2: rt.u32): rt.u32 => { + const f: (a0: rt.u32) => rt.u32[] = (i2: rt.u32): rt.u32[] => { rt.cellSet(calls, rt.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { rt.panicFmt(["consumed"]); @@ -2379,17 +2378,17 @@ export function typed$u32_reserves_closure1(kind: rt.u8, data: rt.ByteSlice, mak } }; if (shape === 0) { - fill$u32_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$u32s_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); } else if (shape === 1) { - fill$u32_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$u32s_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$u32_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: rt.u32): boolean => { + fill$u32s_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: rt.u32[]): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$u32s_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); } else { - fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$u32s_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); } rt.byteVecPush(out, calls.v); } @@ -2610,356 +2609,6 @@ export function typed$u8_u8_u8_reserves_closure2(kind: rt.u8, data: rt.ByteSlice rt.byteVecPush(out, calls.v); } -/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$Big_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { - let len!: rt.usize; - if (coll === 0) { - len = rt.iterToArray(items, "next", 1100).length; - } else if (coll === 1) { - const v: Big.Big[] = []; - rt.iterExtend(v, items, "next", 1100); - len = v.length; - } else if (coll === 2) { - const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - rt.iterExtend(v2, items, "next", 1100); - len = v2.length; - } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; - } else if (coll === 4) { - const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); - rt.dequeExtend(q, items, "next", 1100); - len = q.n; - } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; - } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), "next", 1100); - len = h.d.length; - } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, "next", 1100)); - } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); - } else if (coll === 9) { - const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { - return [t3, 1] as [Big.Big, rt.u32]; - }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); - } else if (coll === 10) { - const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { - return [t2, 1] as [Big.Big, rt.u32]; - }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); - } else if (coll === 11) { - len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { - return a0; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: Big.Big[]): rt.usize => { - return v4.length; - }); - } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: Big.Big = _2[1]; - if (!(i2 < 3)) { - _0 = rt.Err(i2); - } else { - _0 = rt.Ok(t); - } - return _0; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); - if (_53.ok) { - len = _53.value.length; - } else { - len = rt.usizeAdd(256, _53.error); - } - } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); -} - -/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { - let len!: rt.usize; - if (coll === 0) { - len = rt.iterToArray(items, "next", 1100).length; - } else if (coll === 1) { - const v: Big.Big[] = []; - rt.iterExtend(v, items, "next", 1100); - len = v.length; - } else if (coll === 2) { - const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - rt.iterExtend(v2, items, "next", 1100); - len = v2.length; - } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; - } else if (coll === 4) { - const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); - rt.dequeExtend(q, items, "next", 1100); - len = q.n; - } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; - } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), "next", 1100); - len = h.d.length; - } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, "next", 1100)); - } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); - } else if (coll === 9) { - const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { - return [t3, 1] as [Big.Big, rt.u32]; - }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); - } else if (coll === 10) { - const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { - return [t2, 1] as [Big.Big, rt.u32]; - }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); - } else if (coll === 11) { - len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { - return a0; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: Big.Big[]): rt.usize => { - return v4.length; - }); - } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: Big.Big = _2[1]; - if (!(i2 < 3)) { - _0 = rt.Err(i2); - } else { - _0 = rt.Ok(t); - } - return _0; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); - if (_53.ok) { - len = _53.value.length; - } else { - len = rt.usizeAdd(256, _53.error); - } - } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); -} - -/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { - let len!: rt.usize; - if (coll === 0) { - len = rt.iterToArray(items, "next", 1100).length; - } else if (coll === 1) { - const v: Big.Big[] = []; - rt.iterExtend(v, items, "next", 1100); - len = v.length; - } else if (coll === 2) { - const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - rt.iterExtend(v2, items, "next", 1100); - len = v2.length; - } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; - } else if (coll === 4) { - const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); - rt.dequeExtend(q, items, "next", 1100); - len = q.n; - } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; - } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), "next", 1100); - len = h.d.length; - } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, "next", 1100)); - } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); - } else if (coll === 9) { - const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { - return [t3, 1] as [Big.Big, rt.u32]; - }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); - } else if (coll === 10) { - const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { - return [t2, 1] as [Big.Big, rt.u32]; - }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); - } else if (coll === 11) { - len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { - return a0; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: Big.Big[]): rt.usize => { - return v4.length; - }); - } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: Big.Big = _2[1]; - if (!(i2 < 3)) { - _0 = rt.Err(i2); - } else { - _0 = rt.Ok(t); - } - return _0; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); - if (_53.ok) { - len = _53.value.length; - } else { - len = rt.usizeAdd(256, _53.error); - } - } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); -} - -/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$Big_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { - let len!: rt.usize; - if (coll === 0) { - len = rt.iterToArray(items, undefined, 1100, true).length; - } else if (coll === 1) { - const v: Big.Big[] = []; - rt.iterExtend(v, items, undefined, 1100, true); - len = v.length; - } else if (coll === 2) { - const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - rt.iterExtend(v2, items, undefined, 1100, true); - len = v2.length; - } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100, true).n; - } else if (coll === 4) { - const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); - rt.dequeExtend(q, items, undefined, 1100, true); - len = q.n; - } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 1100, true), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; - } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), undefined, 1100, true); - len = h.d.length; - } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, undefined, 1100, true)); - } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); - } else if (coll === 9) { - const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { - return [t3, 1] as [Big.Big, rt.u32]; - }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); - } else if (coll === 10) { - const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { - return [t2, 1] as [Big.Big, rt.u32]; - }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 1104, true)); - } else if (coll === 11) { - len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { - return a0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)), 255, (v4: Big.Big[]): rt.usize => { - return v4.length; - }); - } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: Big.Big = _2[1]; - if (!(i2 < 3)) { - _0 = rt.Err(i2); - } else { - _0 = rt.Ok(t); - } - return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); - if (_53.ok) { - len = _53.value.length; - } else { - len = rt.usizeAdd(256, _53.error); - } - } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); -} - -/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$Big_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { - let len!: rt.usize; - if (coll === 0) { - len = rt.iterToArray(items, "next", 1100).length; - } else if (coll === 1) { - const v: Big.Big[] = []; - rt.iterExtend(v, items, "next", 1100); - len = v.length; - } else if (coll === 2) { - const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - rt.iterExtend(v2, items, "next", 1100); - len = v2.length; - } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; - } else if (coll === 4) { - const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); - rt.dequeExtend(q, items, "next", 1100); - len = q.n; - } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; - } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), "next", 1100); - len = h.d.length; - } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, "next", 1100)); - } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); - } else if (coll === 9) { - const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { - return [t3, 1] as [Big.Big, rt.u32]; - }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); - } else if (coll === 10) { - const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { - return [t2, 1] as [Big.Big, rt.u32]; - }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); - } else if (coll === 11) { - len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { - return a0; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: Big.Big[]): rt.usize => { - return v4.length; - }); - } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: Big.Big = _2[1]; - if (!(i2 < 3)) { - _0 = rt.Err(i2); - } else { - _0 = rt.Ok(t); - } - return _0; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); - if (_53.ok) { - len = _53.value.length; - } else { - len = rt.usizeAdd(256, _53.error); - } - } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); -} - /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ export function fill$Unit_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter, seed: Unit.Unit, out: rt.ByteVec): void { let len!: rt.usize; @@ -3660,6 +3309,361 @@ export function fill$u32_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); } +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32s_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { + let len!: rt.usize; + seed = copy$u32s(seed); + if (coll === 0) { + len = rt.iterToArray(items, "next", 1100).length; + } else if (coll === 1) { + const v: rt.u32[][] = []; + rt.iterExtend(v, items, "next", 1100); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + rt.iterExtend(v2, items, "next", 1100); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; + } else if (coll === 4) { + const _21: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, "next", 1100); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, "next", 1100)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { + return [t3, 1] as [rt.u32[], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { + return [t2, 1] as [rt.u32[], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); + } else if (coll === 11) { + len = mapOr$0ow0wo0(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: rt.u32[][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32[] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32s_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { + let len!: rt.usize; + seed = copy$u32s(seed); + if (coll === 0) { + len = rt.iterToArray(items, "next", 1100).length; + } else if (coll === 1) { + const v: rt.u32[][] = []; + rt.iterExtend(v, items, "next", 1100); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + rt.iterExtend(v2, items, "next", 1100); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; + } else if (coll === 4) { + const _21: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, "next", 1100); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, "next", 1100)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { + return [t3, 1] as [rt.u32[], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { + return [t2, 1] as [rt.u32[], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); + } else if (coll === 11) { + len = mapOr$0ow0wo0(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: rt.u32[][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32[] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32s_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { + let len!: rt.usize; + seed = copy$u32s(seed); + if (coll === 0) { + len = rt.iterToArray(items, "next", 1100).length; + } else if (coll === 1) { + const v: rt.u32[][] = []; + rt.iterExtend(v, items, "next", 1100); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + rt.iterExtend(v2, items, "next", 1100); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; + } else if (coll === 4) { + const _21: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, "next", 1100); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, "next", 1100)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { + return [t3, 1] as [rt.u32[], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { + return [t2, 1] as [rt.u32[], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); + } else if (coll === 11) { + len = mapOr$0ow0wo0(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: rt.u32[][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32[] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32s_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { + let len!: rt.usize; + seed = copy$u32s(seed); + if (coll === 0) { + len = rt.iterToArray(items, undefined, 1100, true).length; + } else if (coll === 1) { + const v: rt.u32[][] = []; + rt.iterExtend(v, items, undefined, 1100, true); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + rt.iterExtend(v2, items, undefined, 1100, true); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100, true).n; + } else if (coll === 4) { + const _21: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, undefined, 1100, true); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1100, true), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), undefined, 1100, true); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, undefined, 1100, true)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { + return [t3, 1] as [rt.u32[], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { + return [t2, 1] as [rt.u32[], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 1104, true)); + } else if (coll === 11) { + len = mapOr$0ow0wo0(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)), 255, (v4: rt.u32[][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32[] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32s_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { + let len!: rt.usize; + seed = copy$u32s(seed); + if (coll === 0) { + len = rt.iterToArray(items, "next", 1100).length; + } else if (coll === 1) { + const v: rt.u32[][] = []; + rt.iterExtend(v, items, "next", 1100); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + rt.iterExtend(v2, items, "next", 1100); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 1100).n; + } else if (coll === 4) { + const _21: rt.u32[][] = rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, "next", 1100); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(copy$u32s(copy$u32s(seed)), 2, copy$u32s), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, "next", 1100)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { + return [t3, 1] as [rt.u32[], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { + return [t2, 1] as [rt.u32[], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); + } else if (coll === 11) { + len = mapOr$0ow0wo0(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: rt.u32[][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32[] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ export function fill$u64_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { let len!: rt.usize; diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 34aa07614..ee8537373 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$Hop, copy$Horizon, copy$Option_u8s, copy$u8_Horizon, copy$u8s, drop$u8_Reverse_Arc_Lopsided } from "./lib.ts"; -import { thenSome$0rsp0eu, then$18np55d } from "./core/bool.ts"; -import { unwrapOr$1tvry1i, unwrapOr$1j4op5y, unwrapOr$0r2bmpr, map$120lney, map$146awhd, map$0lcwx9x, map$0gn4nwv, mapOr$04khdaj, mapOr$1dgdmlk, mapOr$1a3irjf, mapOr$1surhce, mapOr$1w1gbwl, mapOr$1be3nsj, mapOr$0z7fb2w, mapOr$02k4ito } from "./core/option.ts"; +import { copy$Hop, copy$Hops, copy$Horizon, copy$Option_Hops, copy$Option_Option_u8s, copy$Option_u16s, copy$Option_u32s, copy$Option_u32s$2, copy$Option_u64s, copy$Option_u8s, copy$Option_u8s$2, copy$u16s, copy$u32s, copy$u64s, copy$u8_Horizon, copy$u8s, drop$u8_Reverse_Arc_Lopsided } from "./lib.ts"; +import { thenSome$0rsp0eu, then$1c9ust9, then$0b2eeh4, then$18np55d, then$1ghn4qd, then$1dhbcvy, then$1nf265w, then$0l07w38, then$0l8o6jo, then$0uovwq9 } from "./core/bool.ts"; +import { unwrapOr$1tvry1i, unwrapOr$1j4op5y, unwrapOr$0r2bmpr, map$120lney, map$146awhd, map$0lcwx9x, map$0gn4nwv, mapOr$04khdaj, mapOr$0rtxftk, mapOr$0spovx0, mapOr$1bumeih, mapOr$187k0x1, mapOr$1dgdmlk, mapOr$1kiffmd, mapOr$1a3irjf, mapOr$0qqhf4e, mapOr$13q9j26, mapOr$141aobk, mapOr$1afbbm4, mapOr$17y4wkx, mapOr$03mkmku, mapOr$0iyypgq, mapOr$1h1mlmc, mapOr$1xwgm12, mapOr$0nlcxqx, mapOr$0vfd25u, mapOr$1surhce, mapOr$1w1gbwl, mapOr$1be3nsj, mapOr$0z7fb2w, mapOr$02k4ito } from "./core/option.ts"; import * as Hop from "./keys.Hop.ts"; import * as Horizon from "./keys.Horizon.ts"; import * as Liar from "./keys.Liar.ts"; @@ -911,7 +911,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { _137[Symbol.dispose](); _135[Symbol.dispose](); } - const arrays: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; + const arrays_: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; const slices: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; const nested: rt.HashMap<[Uint8Array | undefined, rt.ByteVec], rt.usize> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashOption(rt.hashBytes), rt.hashBytes]), rt.eqTuple([rt.eqOption(rt.eqBytes), rt.eqBytes]))) as rt.HashMap<[Uint8Array | undefined, rt.ByteVec], rt.usize>; @@ -939,7 +939,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.idx(_158[1], 1); const key: Uint8Array = Uint8Array.of(_164, rt.u8Rem(_158[1].data[_158[1].start + 1], 4)); const s: rt.ByteSlice = rt.byteSliceRange(data, i, rt.min(rt.usizeAdd(i, rt.usizeRem(kind as rt.usize, 3)), data.length)); - rt.byteVecPush(out, mapOr$02k4ito(rt.hashInsert(arrays, copy$u8s(key), i), 204, (old: rt.usize): rt.u8 => { + rt.byteVecPush(out, mapOr$02k4ito(rt.hashInsert(arrays_, copy$u8s(key), i), 204, (old: rt.usize): rt.u8 => { return old & 0xff; })); const _193: rt.ByteVec = rt.byteSliceToByteVec(s); @@ -952,7 +952,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.idx(_158[1], 0); const opt: Uint8Array | undefined = thenSome$0rsp0eu(rt.u8Rem(_158[1].data[_158[1].start], 3) !== 0, key); const _211: rt.ByteVec = rt.byteSliceToByteVec(s); - const _210: [Uint8Array | undefined, rt.ByteVec] = [copy$Option_u8s(opt), _211]; + const _210: [Uint8Array | undefined, rt.ByteVec] = [copy$Option_u8s$2(opt), _211]; rt.byteVecPush(out, mapOr$02k4ito(rt.hashInsert(nested, _210, i), 204, (old4: rt.usize): rt.u8 => { return old4 & 0xff; })); @@ -1007,7 +1007,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), mapOr$1surhce(rt.byteSliceGet(data, j), 0, (b3: rt.u8): rt.u8 => { return rt.u8Rem(b3, 4); })); - rt.byteVecPush(out, mapOr$02k4ito(rt.hashGet(arrays, rt.byteSliceView(rt.byteSliceFrom(key2))), 221, (v4: rt.usize): rt.u8 => { + rt.byteVecPush(out, mapOr$02k4ito(rt.hashGet(arrays_, rt.byteSliceView(rt.byteSliceFrom(key2))), 221, (v4: rt.usize): rt.u8 => { return v4 & 0xff; })); rt.byteVecPush(out, mapOr$02k4ito(rt.hashGet(arcs_, new rt.Arc(rt.byteSliceView(rt.byteSliceFrom(key2)))), 221, (v5: rt.usize): rt.u8 => { @@ -1027,7 +1027,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, rt.btreeContains(ordered, s2) ? 1 : 0); if (s2.length >= 2) { const two: rt.ByteSlice = rt.byteSliceRange(s2, 0, 2); - rt.byteVecPush(out, mapOr$02k4ito(rt.hashGet(arrays, rt.byteSliceView(two)), 221, (v9: rt.usize): rt.u8 => { + rt.byteVecPush(out, mapOr$02k4ito(rt.hashGet(arrays_, rt.byteSliceView(two)), 221, (v9: rt.usize): rt.u8 => { return v9 & 0xff; })); rt.byteVecPush(out, mapOr$02k4ito(rt.btreeGet(tree, rt.byteSliceView(two)), 221, (v10: rt.usize): rt.u8 => { @@ -1586,4 +1586,2166 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo } } +/** + * Collections keyed by arrays of each element type, none at all, and many: found by an + * equal array made apart and by the slice each borrows as, ordered as std orders arrays, + * by their elements in turn, and ranged, walked, and edited through entries. A hash + * collection's order is the runtime's, so what it yields is sorted first. + */ +export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _4: rt.u8 = rt.u8Rem(kind, 9); + if (_4 === 0) { + keyed$u16_2_arrays_closure0(data, (b8: rt.u8): rt.u16[] => { + return [(((rt.u8Rem(b8, 4) as rt.u16)) << 8) & 0xffff, rt.u8Rem(b8, 3) as rt.u16]; + }, out); + } else if (_4 === 1) { + keyed$u64_2_arrays_closure1(data, (b7: rt.u8): rt.u64[] => { + return [rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u8Rem(b7, 4) as rt.u64), rt.u64Shl(1, rt.u8Mul(rt.u8Rem(b7, 3), 30))]; + }, out); + } else if (_4 === 2) { + keyed$i32_2_arrays_closure2(data, (b6: rt.u8): rt.i32[] => { + return [rt.i8Rem((b6 << 24) >> 24, 3) as rt.i32, rt.i32Neg(rt.u8Rem(b6, 2) as rt.i32)]; + }, out); + } else if (_4 === 3) { + keyed$char_2_arrays_closure3(data, (b5: rt.u8): rt.char[] => { + return [57344, rt.u8Add(rt.u8Rem(b5, 4), 97) as rt.char]; + }, out); + } else if (_4 === 4) { + keyed$bool_2_arrays_closure4(data, (b4: rt.u8): boolean[] => { + return [rt.u8Rem(b4, 2) === 0, rt.u8Rem(b4, 3) === 0]; + }, out); + } else if (_4 === 5) { + keyed$Option_u8_2_arrays_closure5(data, (b3: rt.u8): Array => { + return [small(b3), small(rt.u8Div(b3, 4))]; + }, out); + } else if (_4 === 6) { + keyed$Hop_2_arrays_closure6(data, (b2: rt.u8): Hop.Hop[] => { + return [{ _0: rt.u64Shl(rt.u8Rem(b2, 3) as rt.u64, 53) }, { _0: rt.u8Rem(b2, 2) as rt.u64 }]; + }, out); + } else if (_4 === 7) { + keyed$u32_0_arrays_closure7(data, (_2: rt.u8): rt.u32[] => { + return []; + }, out); + } else { + keyed$u32_275_arrays_closure8(data, (b: rt.u8): rt.u32[] => { + const _3: rt.u32 = rt.u8Rem(b, 4) as rt.u32; + return Array.from({ length: 275 }, (): rt.u32 => { + return _3; + }); + }, out); + } +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8) => Hop.Hop[], out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$PartialEq))) as rt.HashMap; + const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(Hop.cmp$Ord)) as rt.BTreeMap; + const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$PartialEq))) as rt.HashSet; + const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(Hop.cmp$Ord)) as rt.BTreeSet; + const values: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: Hop.Hop[] = copy$Hops(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: Hop.Hop[] = copy$Hops(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: Hop.Hop[] = copy$Hops(make(b)); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: Hop.Hop[] = copy$Hops(make(b)); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: Hop.Hop[] = copy$Hops(make(b)); + rt.byteVecPush(out, mapOr$0rtxftk(rt.hashInsert(values, _51, _53), 204, (old: Hop.Hop[]): rt.u8 => { + const _6: Hop.Hop[] = make(b); + return rt.eqSlice(Hop.eq$PartialEq)(old, _6) ? 1 : 0; + })); + const _62: Hop.Hop[] = copy$Hops(make(rt.u8Div(b, 2))); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: Hop.Hop[] = copy$Hops(make(rt.u8Div(b, 2))); + const _67: rt.Entry = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry = _67; + const _82: Hop.Hop[] = rt.entryKey(v); + const _85: Hop.Hop[] = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(Hop.eq$PartialEq)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: Hop.Hop[] = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: Hop.Hop[] = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: Hop.Hop[] = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: Hop.Hop[] = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: Hop.Hop[] = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: Hop.Hop[] = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$0spovx0(rt.hashGetKeyValue(map, _134), 221, (_2: [Hop.Hop[], rt.u8]): rt.u8 => { + return rt.eqSlice(Hop.eq$PartialEq)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$0spovx0(rt.btreeGetKeyValue(tree, key), 221, (_22: [Hop.Hop[], rt.u8]): rt.u8 => { + const _5: Hop.Hop[] = rt.sliceRange(_22[0], 0); + const _63: Hop.Hop[] = rt.sliceRange(key, 0); + return rt.eqSlice(Hop.eq$PartialEq)(_5, _63) ? 1 : 0; + }); + const _147: Hop.Hop[] = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$0rtxftk(rt.hashKey(set, _147), 221, (k: Hop.Hop[]): rt.u8 => { + return rt.eqSlice(Hop.eq$PartialEq)(k, key) ? 1 : 0; + }), mapOr$0rtxftk(rt.hashGet(values, b2), 221, (v2: Hop.Hop[]): rt.u8 => { + return rt.eqSlice(Hop.eq$PartialEq)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: Hop.Hop[] } = { end: copy$Hops(copy$Hops(key)) }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff); + const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd))), (k2: Hop.Hop[]): rt.u8 => { + const order_ = rt.cmpSlice(Hop.partialCmp$PartialOrd)(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: Hop.Hop[][] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter = rt.sliceWindows(keys_, 2); + while (true) { + const _206: Hop.Hop[][] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: Hop.Hop[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(Hop.partialCmp$PartialOrd)(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: Hop.Hop[] = _206[0]; + rt.idx(_206, 1); + const _532: Hop.Hop[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(Hop.cmp$Ord)(_531, _532); + rt.idx(_206, 0); + const _236: Hop.Hop[] = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: Hop.Hop[] = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(Hop.cmp$Ord)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$0spovx0(rt.btreeFirst(tree), 221, (_24: [Hop.Hop[], rt.u8]): rt.u8 => { + const _83: Hop.Hop[] | undefined = _24[0]; + const _102: Hop.Hop[] | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(Hop.eq$PartialEq))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$0rtxftk(rt.btreeFirstKey(ordered, true), 221, (k3: Hop.Hop[]): rt.u8 => { + const _57: Hop.Hop[] | undefined = k3; + const _84: Hop.Hop[] | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(Hop.eq$PartialEq))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: Hop.Hop[] = make(part10); + const _268: Hop.Hop[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$0spovx0(rt.hashRemoveEntry(map, probe), 238, (_26: [Hop.Hop[], rt.u8]): rt.u8 => { + const k4: Hop.Hop[] = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(Hop.eq$PartialEq)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: Hop.Hop[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: Hop.Hop[] = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: Hop.Hop[] = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$0rtxftk(rt.btreePopKey(ordered), 221, (k5: Hop.Hop[]): rt.u8 => { + return rt.cmpSlice(Hop.partialCmp$PartialOrd)(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: Hop.Hop[], v4: rt.Place): boolean => { + const _512: Hop.Hop[] = rt.sliceRange(k6, 0); + const _611: Hop.Hop[] = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(Hop.partialCmp$PartialOrd)(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Hop.Hop[] => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(Hop.cmp$Ord)) as rt.BTreeSet, _330, true, undefined, undefined, 16, true); + const _335: [Hop.Hop[], rt.u8][] = [[copy$Hops(make(0)), 1] as [Hop.Hop[], rt.u8], [copy$Hops(make(1)), 2] as [Hop.Hop[], rt.u8]]; + const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$PartialEq))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 58720256); + for (const b3 of rt.byteSliceView(data)) { + const _354: Hop.Hop[] = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: Hop.Hop[] = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: Hop.Hop[] = copy$Hops(make(b3)); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [Hop.Hop[], rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(Hop.partialCmp$PartialOrd), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [Hop.Hop[], rt.u8]): rt.u8 => { + const k7: Hop.Hop[] = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet = rt.btreeClone(made, copy$Hops, undefined); + const _405: Hop.Hop[] = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: Hop.Hop[]): boolean => { + const _315: Hop.Hop[] = rt.sliceRange(k8, 0); + const _411: Hop.Hop[] = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(Hop.partialCmp$PartialOrd)(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, Hop.Hop[]], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(Hop.cmp$Ord)])) as rt.BTreeMap<[rt.u8, Hop.Hop[]], rt.u8>; + const options_: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined)), rt.eqOption(rt.eqSlice(Hop.eq$PartialEq)))) as rt.HashSet; + const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$PartialEq))) as rt.HashMap; + const lists: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(Hop.cmp$Ord)) as rt.BTreeSet; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, Hop.Hop[]] = [rt.u8Rem(b4, 2), copy$Hops(make(b4))]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: Hop.Hop[] | undefined = copy$Option_Hops(then$1c9ust9(rt.u8Rem(b4, 3) !== 0, (): Hop.Hop[] => { + return make(b4); + })); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: Hop.Hop[] = make(b4).map(copy$Hop); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: Hop.Hop[] = make(rt.u8Div(b4, 2)).map(copy$Hop); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: Hop.Hop[] = make(_488); + const _501: Hop.Hop[] | undefined = copy$Hops(key2); + const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; + const _508: Hop.Hop[] = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: Hop.Hop[] = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: rt.u8) => Array, out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; + const tree: rt.BTreeMap, rt.u8> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeMap, rt.u8>; + const set: rt.HashSet> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashSet>; + const ordered: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeSet>; + const values: rt.HashMap> = rt.hashNew() as rt.HashMap>; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: Array = copy$Option_u8s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: Array = copy$Option_u8s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: Array = copy$Option_u8s(make(b)); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: Array = copy$Option_u8s(make(b)); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: Array = copy$Option_u8s(make(b)); + rt.byteVecPush(out, mapOr$1bumeih(rt.hashInsert(values, _51, _53), 204, (old: Array): rt.u8 => { + const _6: Array = make(b); + return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + })); + const _62: Array = copy$Option_u8s(make(rt.u8Div(b, 2))); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: Array = copy$Option_u8s(make(rt.u8Div(b, 2))); + const _67: rt.Entry, rt.u8> = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry, rt.u8> = _67; + const _82: Array = rt.entryKey(v); + const _85: Array = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: Array = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: Array = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: Array = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: Array = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: Array = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: Array = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$187k0x1(rt.hashGetKeyValue(map, _134), 221, (_2: [Array, rt.u8]): rt.u8 => { + return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$187k0x1(rt.btreeGetKeyValue(tree, key), 221, (_22: [Array, rt.u8]): rt.u8 => { + const _5: Array = rt.sliceRange(_22[0], 0); + const _63: Array = rt.sliceRange(key, 0); + return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + }); + const _147: Array = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$1bumeih(rt.hashKey(set, _147), 221, (k: Array): rt.u8 => { + return rt.eqSlice(rt.same)(k, key) ? 1 : 0; + }), mapOr$1bumeih(rt.hashGet(values, b2), 221, (v2: Array): rt.u8 => { + return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: Array } = { end: copy$Option_u8s(copy$Option_u8s(key)) }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); + const _170: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound>, { tag: "Unbounded" } as rt.RangeBound>]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: Array): rt.u8 => { + const order_ = rt.cmpSlice(rt.cmpOption(rt.cmp))(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Unbounded" } as rt.RangeBound>, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound>]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: Array[] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter[]> = rt.sliceWindows(keys_, 2); + while (true) { + const _206: Array[] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: Array = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: Array = _206[0]; + rt.idx(_206, 1); + const _532: Array = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmpOption(rt.cmp))(_531, _532); + rt.idx(_206, 0); + const _236: Array = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: Array = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmpOption(rt.cmp))(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$187k0x1(rt.btreeFirst(tree), 221, (_24: [Array, rt.u8]): rt.u8 => { + const _83: Array | undefined = _24[0]; + const _102: Array | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$1bumeih(rt.btreeFirstKey(ordered, true), 221, (k3: Array): rt.u8 => { + const _57: Array | undefined = k3; + const _84: Array | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: Array = make(part10); + const _268: Array = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$187k0x1(rt.hashRemoveEntry(map, probe), 238, (_26: [Array, rt.u8]): rt.u8 => { + const k4: Array = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: Array = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: Array = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: Array = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$1bumeih(rt.btreePopKey(ordered), 221, (k5: Array): rt.u8 => { + return rt.cmpSlice(rt.cmpOption(rt.cmp))(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: Array, v4: rt.Place): boolean => { + const _512: Array = rt.sliceRange(k6, 0); + const _611: Array = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Array => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet> = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeSet>, _330, true, undefined, undefined, 4, true); + const _335: [Array, rt.u8][] = [[copy$Option_u8s(make(0)), 1] as [Array, rt.u8], [copy$Option_u8s(make(1)), 2] as [Array, rt.u8]]; + const counts: rt.HashMap, rt.u8> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>, rt.iterSlice(_335), undefined, undefined, undefined, 234881024); + for (const b3 of rt.byteSliceView(data)) { + const _354: Array = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: Array = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: Array = copy$Option_u8s(make(b3)); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [Array, rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(rt.cmpOption(rt.cmp)), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [Array, rt.u8]): rt.u8 => { + const k7: Array = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet> = rt.btreeClone(made, copy$Option_u8s, undefined); + const _405: Array = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet> = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: Array): boolean => { + const _315: Array = rt.sliceRange(k8, 0); + const _411: Array = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, Array], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmpOption(rt.cmp))])) as rt.BTreeMap<[rt.u8, Array], rt.u8>; + const options_: rt.HashSet | undefined> = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hashOption(rt.hash8))), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet | undefined>; + const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; + const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeSet>; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, Array] = [rt.u8Rem(b4, 2), copy$Option_u8s(make(b4))]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: Array | undefined = copy$Option_Option_u8s(then$0b2eeh4(rt.u8Rem(b4, 3) !== 0, (): Array => { + return make(b4); + })); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: Array = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: Array = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: Array = make(_488); + const _501: Array | undefined = copy$Option_u8s(key2); + const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; + const _508: Array = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: Array = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound>, { tag: "Unbounded" } as rt.RangeBound>]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u8) => boolean[], out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap; + const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; + const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashSet; + const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const values: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: boolean[] = make(b); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: boolean[] = make(b); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: boolean[] = make(b); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: boolean[] = make(b); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: boolean[] = make(b); + rt.byteVecPush(out, mapOr$0qqhf4e(rt.hashInsert(values, _51, _53), 204, (old: boolean[]): rt.u8 => { + const _6: boolean[] = make(b); + return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + })); + const _62: boolean[] = make(rt.u8Div(b, 2)); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: boolean[] = make(rt.u8Div(b, 2)); + const _67: rt.Entry = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry = _67; + const _82: boolean[] = rt.entryKey(v); + const _85: boolean[] = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: boolean[] = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: boolean[] = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: boolean[] = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: boolean[] = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: boolean[] = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: boolean[] = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$13q9j26(rt.hashGetKeyValue(map, _134), 221, (_2: [boolean[], rt.u8]): rt.u8 => { + return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$13q9j26(rt.btreeGetKeyValue(tree, key), 221, (_22: [boolean[], rt.u8]): rt.u8 => { + const _5: boolean[] = rt.sliceRange(_22[0], 0); + const _63: boolean[] = rt.sliceRange(key, 0); + return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + }); + const _147: boolean[] = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$0qqhf4e(rt.hashKey(set, _147), 221, (k: boolean[]): rt.u8 => { + return rt.eqSlice(rt.same)(k, key) ? 1 : 0; + }), mapOr$0qqhf4e(rt.hashGet(values, b2), 221, (v2: boolean[]): rt.u8 => { + return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: boolean[] } = { end: key }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); + const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: boolean[]): rt.u8 => { + const order_ = rt.cmpSlice(rt.cmp)(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: boolean[][] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter = rt.sliceWindows(keys_, 2); + while (true) { + const _206: boolean[][] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: boolean[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: boolean[] = _206[0]; + rt.idx(_206, 1); + const _532: boolean[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + rt.idx(_206, 0); + const _236: boolean[] = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: boolean[] = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$13q9j26(rt.btreeFirst(tree), 221, (_24: [boolean[], rt.u8]): rt.u8 => { + const _83: boolean[] | undefined = _24[0]; + const _102: boolean[] | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$0qqhf4e(rt.btreeFirstKey(ordered, true), 221, (k3: boolean[]): rt.u8 => { + const _57: boolean[] | undefined = k3; + const _84: boolean[] | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: boolean[] = make(part10); + const _268: boolean[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$13q9j26(rt.hashRemoveEntry(map, probe), 238, (_26: [boolean[], rt.u8]): rt.u8 => { + const k4: boolean[] = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: boolean[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: boolean[] = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: boolean[] = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$0qqhf4e(rt.btreePopKey(ordered), 221, (k5: boolean[]): rt.u8 => { + return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: boolean[], v4: rt.Place): boolean => { + const _512: boolean[] = rt.sliceRange(k6, 0); + const _611: boolean[] = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): boolean[] => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 2, true); + const _335: [boolean[], rt.u8][] = [[make(0), 1] as [boolean[], rt.u8], [make(1), 2] as [boolean[], rt.u8]]; + const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 234881024); + for (const b3 of rt.byteSliceView(data)) { + const _354: boolean[] = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: boolean[] = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: boolean[] = make(b3); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [boolean[], rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(rt.cmp), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [boolean[], rt.u8]): rt.u8 => { + const k7: boolean[] = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); + const _405: boolean[] = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: boolean[]): boolean => { + const _315: boolean[] = rt.sliceRange(k8, 0); + const _411: boolean[] = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, boolean[]], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, boolean[]], rt.u8>; + const options_: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash8)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; + const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap; + const lists: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, boolean[]] = [rt.u8Rem(b4, 2), make(b4)]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: boolean[] | undefined = then$1ghn4qd(rt.u8Rem(b4, 3) !== 0, (): boolean[] => { + return make(b4); + }); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: boolean[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: boolean[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: boolean[] = make(_488); + const _497: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; + const _508: boolean[] = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: boolean[] = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u8) => rt.char[], out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; + const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; + const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; + const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const values: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: rt.char[] = make(b); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: rt.char[] = make(b); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: rt.char[] = make(b); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: rt.char[] = make(b); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: rt.char[] = make(b); + rt.byteVecPush(out, mapOr$141aobk(rt.hashInsert(values, _51, _53), 204, (old: rt.char[]): rt.u8 => { + const _6: rt.char[] = make(b); + return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + })); + const _62: rt.char[] = make(rt.u8Div(b, 2)); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: rt.char[] = make(rt.u8Div(b, 2)); + const _67: rt.Entry = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry = _67; + const _82: rt.char[] = rt.entryKey(v); + const _85: rt.char[] = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: rt.char[] = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: rt.char[] = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: rt.char[] = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: rt.char[] = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: rt.char[] = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: rt.char[] = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$1afbbm4(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.char[], rt.u8]): rt.u8 => { + return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$1afbbm4(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.char[], rt.u8]): rt.u8 => { + const _5: rt.char[] = rt.sliceRange(_22[0], 0); + const _63: rt.char[] = rt.sliceRange(key, 0); + return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + }); + const _147: rt.char[] = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$141aobk(rt.hashKey(set, _147), 221, (k: rt.char[]): rt.u8 => { + return rt.eqSlice(rt.same)(k, key) ? 1 : 0; + }), mapOr$141aobk(rt.hashGet(values, b2), 221, (v2: rt.char[]): rt.u8 => { + return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: rt.char[] } = { end: key }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); + const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.char[]): rt.u8 => { + const order_ = rt.cmpSlice(rt.cmp)(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: rt.char[][] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter = rt.sliceWindows(keys_, 2); + while (true) { + const _206: rt.char[][] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: rt.char[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: rt.char[] = _206[0]; + rt.idx(_206, 1); + const _532: rt.char[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + rt.idx(_206, 0); + const _236: rt.char[] = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: rt.char[] = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$1afbbm4(rt.btreeFirst(tree), 221, (_24: [rt.char[], rt.u8]): rt.u8 => { + const _83: rt.char[] | undefined = _24[0]; + const _102: rt.char[] | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$141aobk(rt.btreeFirstKey(ordered, true), 221, (k3: rt.char[]): rt.u8 => { + const _57: rt.char[] | undefined = k3; + const _84: rt.char[] | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: rt.char[] = make(part10); + const _268: rt.char[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$1afbbm4(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.char[], rt.u8]): rt.u8 => { + const k4: rt.char[] = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: rt.char[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: rt.char[] = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: rt.char[] = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$141aobk(rt.btreePopKey(ordered), 221, (k5: rt.char[]): rt.u8 => { + return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: rt.char[], v4: rt.Place): boolean => { + const _512: rt.char[] = rt.sliceRange(k6, 0); + const _611: rt.char[] = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.char[] => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 8, true); + const _335: [rt.char[], rt.u8][] = [[make(0), 1] as [rt.char[], rt.u8], [make(1), 2] as [rt.char[], rt.u8]]; + const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 117440512); + for (const b3 of rt.byteSliceView(data)) { + const _354: rt.char[] = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: rt.char[] = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: rt.char[] = make(b3); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [rt.char[], rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(rt.cmp), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [rt.char[], rt.u8]): rt.u8 => { + const k7: rt.char[] = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); + const _405: rt.char[] = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.char[]): boolean => { + const _315: rt.char[] = rt.sliceRange(k8, 0); + const _411: rt.char[] = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, rt.char[]], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.char[]], rt.u8>; + const options_: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash32)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; + const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; + const lists: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, rt.char[]] = [rt.u8Rem(b4, 2), make(b4)]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: rt.char[] | undefined = then$1dhbcvy(rt.u8Rem(b4, 3) !== 0, (): rt.char[] => { + return make(b4); + }); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: rt.char[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: rt.char[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: rt.char[] = make(_488); + const _497: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; + const _508: rt.char[] = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: rt.char[] = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8) => rt.i32[], out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; + const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; + const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; + const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const values: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: rt.i32[] = make(b); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: rt.i32[] = make(b); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: rt.i32[] = make(b); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: rt.i32[] = make(b); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: rt.i32[] = make(b); + rt.byteVecPush(out, mapOr$17y4wkx(rt.hashInsert(values, _51, _53), 204, (old: rt.i32[]): rt.u8 => { + const _6: rt.i32[] = make(b); + return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + })); + const _62: rt.i32[] = make(rt.u8Div(b, 2)); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: rt.i32[] = make(rt.u8Div(b, 2)); + const _67: rt.Entry = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry = _67; + const _82: rt.i32[] = rt.entryKey(v); + const _85: rt.i32[] = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: rt.i32[] = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: rt.i32[] = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: rt.i32[] = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: rt.i32[] = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: rt.i32[] = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: rt.i32[] = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$03mkmku(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.i32[], rt.u8]): rt.u8 => { + return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$03mkmku(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.i32[], rt.u8]): rt.u8 => { + const _5: rt.i32[] = rt.sliceRange(_22[0], 0); + const _63: rt.i32[] = rt.sliceRange(key, 0); + return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + }); + const _147: rt.i32[] = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$17y4wkx(rt.hashKey(set, _147), 221, (k: rt.i32[]): rt.u8 => { + return rt.eqSlice(rt.same)(k, key) ? 1 : 0; + }), mapOr$17y4wkx(rt.hashGet(values, b2), 221, (v2: rt.i32[]): rt.u8 => { + return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: rt.i32[] } = { end: key }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); + const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.i32[]): rt.u8 => { + const order_ = rt.cmpSlice(rt.cmp)(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: rt.i32[][] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter = rt.sliceWindows(keys_, 2); + while (true) { + const _206: rt.i32[][] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: rt.i32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: rt.i32[] = _206[0]; + rt.idx(_206, 1); + const _532: rt.i32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + rt.idx(_206, 0); + const _236: rt.i32[] = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: rt.i32[] = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$03mkmku(rt.btreeFirst(tree), 221, (_24: [rt.i32[], rt.u8]): rt.u8 => { + const _83: rt.i32[] | undefined = _24[0]; + const _102: rt.i32[] | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$17y4wkx(rt.btreeFirstKey(ordered, true), 221, (k3: rt.i32[]): rt.u8 => { + const _57: rt.i32[] | undefined = k3; + const _84: rt.i32[] | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: rt.i32[] = make(part10); + const _268: rt.i32[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$03mkmku(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.i32[], rt.u8]): rt.u8 => { + const k4: rt.i32[] = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: rt.i32[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: rt.i32[] = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: rt.i32[] = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$17y4wkx(rt.btreePopKey(ordered), 221, (k5: rt.i32[]): rt.u8 => { + return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: rt.i32[], v4: rt.Place): boolean => { + const _512: rt.i32[] = rt.sliceRange(k6, 0); + const _611: rt.i32[] = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.i32[] => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 8, true); + const _335: [rt.i32[], rt.u8][] = [[make(0), 1] as [rt.i32[], rt.u8], [make(1), 2] as [rt.i32[], rt.u8]]; + const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 117440512); + for (const b3 of rt.byteSliceView(data)) { + const _354: rt.i32[] = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: rt.i32[] = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: rt.i32[] = make(b3); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [rt.i32[], rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(rt.cmp), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [rt.i32[], rt.u8]): rt.u8 => { + const k7: rt.i32[] = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); + const _405: rt.i32[] = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.i32[]): boolean => { + const _315: rt.i32[] = rt.sliceRange(k8, 0); + const _411: rt.i32[] = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, rt.i32[]], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.i32[]], rt.u8>; + const options_: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash32)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; + const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; + const lists: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, rt.i32[]] = [rt.u8Rem(b4, 2), make(b4)]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: rt.i32[] | undefined = then$1nf265w(rt.u8Rem(b4, 3) !== 0, (): rt.i32[] => { + return make(b4); + }); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: rt.i32[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: rt.i32[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: rt.i32[] = make(_488); + const _497: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; + const _508: rt.i32[] = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: rt.i32[] = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16[], out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashMap; + const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; + const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashSet; + const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const values: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: rt.u16[] = copy$u16s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: rt.u16[] = copy$u16s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: rt.u16[] = copy$u16s(make(b)); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: rt.u16[] = copy$u16s(make(b)); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: rt.u16[] = copy$u16s(make(b)); + rt.byteVecPush(out, mapOr$1kiffmd(rt.hashInsert(values, _51, _53), 204, (old: rt.u16[]): rt.u8 => { + const _6: rt.u16[] = make(b); + return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + })); + const _62: rt.u16[] = copy$u16s(make(rt.u8Div(b, 2))); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: rt.u16[] = copy$u16s(make(rt.u8Div(b, 2))); + const _67: rt.Entry = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry = _67; + const _82: rt.u16[] = rt.entryKey(v); + const _85: rt.u16[] = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: rt.u16[] = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: rt.u16[] = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: rt.u16[] = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: rt.u16[] = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: rt.u16[] = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: rt.u16[] = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$0iyypgq(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.u16[], rt.u8]): rt.u8 => { + return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$0iyypgq(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.u16[], rt.u8]): rt.u8 => { + const _5: rt.u16[] = rt.sliceRange(_22[0], 0); + const _63: rt.u16[] = rt.sliceRange(key, 0); + return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + }); + const _147: rt.u16[] = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$1kiffmd(rt.hashKey(set, _147), 221, (k: rt.u16[]): rt.u8 => { + return rt.eqSlice(rt.same)(k, key) ? 1 : 0; + }), mapOr$1kiffmd(rt.hashGet(values, b2), 221, (v2: rt.u16[]): rt.u8 => { + return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: rt.u16[] } = { end: copy$u16s(copy$u16s(key)) }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); + const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.u16[]): rt.u8 => { + const order_ = rt.cmpSlice(rt.cmp)(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: rt.u16[][] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter = rt.sliceWindows(keys_, 2); + while (true) { + const _206: rt.u16[][] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: rt.u16[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: rt.u16[] = _206[0]; + rt.idx(_206, 1); + const _532: rt.u16[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + rt.idx(_206, 0); + const _236: rt.u16[] = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: rt.u16[] = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$0iyypgq(rt.btreeFirst(tree), 221, (_24: [rt.u16[], rt.u8]): rt.u8 => { + const _83: rt.u16[] | undefined = _24[0]; + const _102: rt.u16[] | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$1kiffmd(rt.btreeFirstKey(ordered, true), 221, (k3: rt.u16[]): rt.u8 => { + const _57: rt.u16[] | undefined = k3; + const _84: rt.u16[] | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: rt.u16[] = make(part10); + const _268: rt.u16[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$0iyypgq(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.u16[], rt.u8]): rt.u8 => { + const k4: rt.u16[] = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: rt.u16[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: rt.u16[] = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: rt.u16[] = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$1kiffmd(rt.btreePopKey(ordered), 221, (k5: rt.u16[]): rt.u8 => { + return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: rt.u16[], v4: rt.Place): boolean => { + const _512: rt.u16[] = rt.sliceRange(k6, 0); + const _611: rt.u16[] = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u16[] => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 4, true); + const _335: [rt.u16[], rt.u8][] = [[copy$u16s(make(0)), 1] as [rt.u16[], rt.u8], [copy$u16s(make(1)), 2] as [rt.u16[], rt.u8]]; + const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 234881024); + for (const b3 of rt.byteSliceView(data)) { + const _354: rt.u16[] = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: rt.u16[] = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: rt.u16[] = copy$u16s(make(b3)); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [rt.u16[], rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(rt.cmp), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [rt.u16[], rt.u8]): rt.u8 => { + const k7: rt.u16[] = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet = rt.btreeClone(made, copy$u16s, undefined); + const _405: rt.u16[] = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.u16[]): boolean => { + const _315: rt.u16[] = rt.sliceRange(k8, 0); + const _411: rt.u16[] = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, rt.u16[]], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.u16[]], rt.u8>; + const options_: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash16)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; + const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashMap; + const lists: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, rt.u16[]] = [rt.u8Rem(b4, 2), copy$u16s(make(b4))]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: rt.u16[] | undefined = copy$Option_u16s(then$0l07w38(rt.u8Rem(b4, 3) !== 0, (): rt.u16[] => { + return make(b4); + })); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: rt.u16[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: rt.u16[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: rt.u16[] = make(_488); + const _501: rt.u16[] | undefined = copy$u16s(key2); + const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; + const _508: rt.u16[] = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: rt.u16[] = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; + const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; + const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; + const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const values: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: rt.u32[] = copy$u32s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: rt.u32[] = copy$u32s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: rt.u32[] = copy$u32s(make(b)); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: rt.u32[] = copy$u32s(make(b)); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: rt.u32[] = copy$u32s(make(b)); + rt.byteVecPush(out, mapOr$1h1mlmc(rt.hashInsert(values, _51, _53), 204, (old: rt.u32[]): rt.u8 => { + const _6: rt.u32[] = make(b); + return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + })); + const _62: rt.u32[] = copy$u32s(make(rt.u8Div(b, 2))); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: rt.u32[] = copy$u32s(make(rt.u8Div(b, 2))); + const _67: rt.Entry = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry = _67; + const _82: rt.u32[] = rt.entryKey(v); + const _85: rt.u32[] = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: rt.u32[] = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: rt.u32[] = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: rt.u32[] = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: rt.u32[] = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: rt.u32[] = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: rt.u32[] = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$1xwgm12(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.u32[], rt.u8]): rt.u8 => { + return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$1xwgm12(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.u32[], rt.u8]): rt.u8 => { + const _5: rt.u32[] = rt.sliceRange(_22[0], 0); + const _63: rt.u32[] = rt.sliceRange(key, 0); + return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + }); + const _147: rt.u32[] = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$1h1mlmc(rt.hashKey(set, _147), 221, (k: rt.u32[]): rt.u8 => { + return rt.eqSlice(rt.same)(k, key) ? 1 : 0; + }), mapOr$1h1mlmc(rt.hashGet(values, b2), 221, (v2: rt.u32[]): rt.u8 => { + return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: rt.u32[] } = { end: copy$u32s(copy$u32s(key)) }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); + const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.u32[]): rt.u8 => { + const order_ = rt.cmpSlice(rt.cmp)(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: rt.u32[][] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter = rt.sliceWindows(keys_, 2); + while (true) { + const _206: rt.u32[][] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: rt.u32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: rt.u32[] = _206[0]; + rt.idx(_206, 1); + const _532: rt.u32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + rt.idx(_206, 0); + const _236: rt.u32[] = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: rt.u32[] = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$1xwgm12(rt.btreeFirst(tree), 221, (_24: [rt.u32[], rt.u8]): rt.u8 => { + const _83: rt.u32[] | undefined = _24[0]; + const _102: rt.u32[] | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$1h1mlmc(rt.btreeFirstKey(ordered, true), 221, (k3: rt.u32[]): rt.u8 => { + const _57: rt.u32[] | undefined = k3; + const _84: rt.u32[] | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: rt.u32[] = make(part10); + const _268: rt.u32[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$1xwgm12(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.u32[], rt.u8]): rt.u8 => { + const k4: rt.u32[] = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: rt.u32[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: rt.u32[] = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: rt.u32[] = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$1h1mlmc(rt.btreePopKey(ordered), 221, (k5: rt.u32[]): rt.u8 => { + return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: rt.u32[], v4: rt.Place): boolean => { + const _512: rt.u32[] = rt.sliceRange(k6, 0); + const _611: rt.u32[] = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u32[] => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 0, true); + const _335: [rt.u32[], rt.u8][] = [[copy$u32s(make(0)), 1] as [rt.u32[], rt.u8], [copy$u32s(make(1)), 2] as [rt.u32[], rt.u8]]; + const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 234881024); + for (const b3 of rt.byteSliceView(data)) { + const _354: rt.u32[] = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: rt.u32[] = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: rt.u32[] = copy$u32s(make(b3)); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [rt.u32[], rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(rt.cmp), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [rt.u32[], rt.u8]): rt.u8 => { + const k7: rt.u32[] = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet = rt.btreeClone(made, copy$u32s, undefined); + const _405: rt.u32[] = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.u32[]): boolean => { + const _315: rt.u32[] = rt.sliceRange(k8, 0); + const _411: rt.u32[] = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, rt.u32[]], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.u32[]], rt.u8>; + const options_: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash32)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; + const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; + const lists: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, rt.u32[]] = [rt.u8Rem(b4, 2), copy$u32s(make(b4))]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: rt.u32[] | undefined = copy$Option_u32s(then$0l8o6jo(rt.u8Rem(b4, 3) !== 0, (): rt.u32[] => { + return make(b4); + })); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: rt.u32[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: rt.u32[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: rt.u32[] = make(_488); + const _501: rt.u32[] | undefined = copy$u32s(key2); + const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; + const _508: rt.u32[] = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: rt.u32[] = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; + const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; + const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; + const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const values: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: rt.u32[] = copy$u32s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: rt.u32[] = copy$u32s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: rt.u32[] = copy$u32s(make(b)); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: rt.u32[] = copy$u32s(make(b)); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: rt.u32[] = copy$u32s(make(b)); + rt.byteVecPush(out, mapOr$1h1mlmc(rt.hashInsert(values, _51, _53), 204, (old: rt.u32[]): rt.u8 => { + const _6: rt.u32[] = make(b); + return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + })); + const _62: rt.u32[] = copy$u32s(make(rt.u8Div(b, 2))); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: rt.u32[] = copy$u32s(make(rt.u8Div(b, 2))); + const _67: rt.Entry = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry = _67; + const _82: rt.u32[] = rt.entryKey(v); + const _85: rt.u32[] = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: rt.u32[] = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: rt.u32[] = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: rt.u32[] = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: rt.u32[] = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: rt.u32[] = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: rt.u32[] = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$1xwgm12(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.u32[], rt.u8]): rt.u8 => { + return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$1xwgm12(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.u32[], rt.u8]): rt.u8 => { + const _5: rt.u32[] = rt.sliceRange(_22[0], 0); + const _63: rt.u32[] = rt.sliceRange(key, 0); + return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + }); + const _147: rt.u32[] = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$1h1mlmc(rt.hashKey(set, _147), 221, (k: rt.u32[]): rt.u8 => { + return rt.eqSlice(rt.same)(k, key) ? 1 : 0; + }), mapOr$1h1mlmc(rt.hashGet(values, b2), 221, (v2: rt.u32[]): rt.u8 => { + return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: rt.u32[] } = { end: copy$u32s(copy$u32s(key)) }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); + const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.u32[]): rt.u8 => { + const order_ = rt.cmpSlice(rt.cmp)(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: rt.u32[][] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter = rt.sliceWindows(keys_, 2); + while (true) { + const _206: rt.u32[][] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: rt.u32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: rt.u32[] = _206[0]; + rt.idx(_206, 1); + const _532: rt.u32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + rt.idx(_206, 0); + const _236: rt.u32[] = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: rt.u32[] = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$1xwgm12(rt.btreeFirst(tree), 221, (_24: [rt.u32[], rt.u8]): rt.u8 => { + const _83: rt.u32[] | undefined = _24[0]; + const _102: rt.u32[] | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$1h1mlmc(rt.btreeFirstKey(ordered, true), 221, (k3: rt.u32[]): rt.u8 => { + const _57: rt.u32[] | undefined = k3; + const _84: rt.u32[] | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: rt.u32[] = make(part10); + const _268: rt.u32[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$1xwgm12(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.u32[], rt.u8]): rt.u8 => { + const k4: rt.u32[] = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: rt.u32[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: rt.u32[] = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: rt.u32[] = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$1h1mlmc(rt.btreePopKey(ordered), 221, (k5: rt.u32[]): rt.u8 => { + return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: rt.u32[], v4: rt.Place): boolean => { + const _512: rt.u32[] = rt.sliceRange(k6, 0); + const _611: rt.u32[] = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u32[] => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 1100, true); + const _335: [rt.u32[], rt.u8][] = [[copy$u32s(make(0)), 1] as [rt.u32[], rt.u8], [copy$u32s(make(1)), 2] as [rt.u32[], rt.u8]]; + const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 917504); + for (const b3 of rt.byteSliceView(data)) { + const _354: rt.u32[] = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: rt.u32[] = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: rt.u32[] = copy$u32s(make(b3)); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [rt.u32[], rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(rt.cmp), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [rt.u32[], rt.u8]): rt.u8 => { + const k7: rt.u32[] = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet = rt.btreeClone(made, copy$u32s, undefined); + const _405: rt.u32[] = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.u32[]): boolean => { + const _315: rt.u32[] = rt.sliceRange(k8, 0); + const _411: rt.u32[] = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, rt.u32[]], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.u32[]], rt.u8>; + const options_: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash32)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; + const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; + const lists: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, rt.u32[]] = [rt.u8Rem(b4, 2), copy$u32s(make(b4))]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: rt.u32[] | undefined = copy$Option_u32s$2(then$0l8o6jo(rt.u8Rem(b4, 3) !== 0, (): rt.u32[] => { + return make(b4); + })); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: rt.u32[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: rt.u32[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: rt.u32[] = make(_488); + const _501: rt.u32[] | undefined = copy$u32s(key2); + const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; + const _508: rt.u32[] = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: rt.u32[] = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + +/** `arrays` of keys `make` makes of each byte. */ +export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { + let _95!: rt.u8; + let _488!: rt.u8; + const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashMap; + const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; + const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashSet; + const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const values: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13[0]; + const b: rt.u8 = _13[1]; + const i2: rt.u8 = i & 0xff; + const _23: rt.u64[] = copy$u64s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + const _30: rt.u64[] = copy$u64s(make(b)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + const _38: rt.u64[] = copy$u64s(make(b)); + const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _44: rt.u64[] = copy$u64s(make(b)); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rt.u8 = rt.u8Rem(b, 4); + const _53: rt.u64[] = copy$u64s(make(b)); + rt.byteVecPush(out, mapOr$0nlcxqx(rt.hashInsert(values, _51, _53), 204, (old: rt.u64[]): rt.u8 => { + const _6: rt.u64[] = make(b); + return rt.eqSlice(rt.u64Eq)(old, _6) ? 1 : 0; + })); + const _62: rt.u64[] = copy$u64s(make(rt.u8Div(b, 2))); + const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + _59.v = _59.v ^ 64; + const _69: rt.u64[] = copy$u64s(make(rt.u8Div(b, 2))); + const _67: rt.Entry = rt.entry(tree, _69); + if (!rt.entryOccupied(_67)) { + const v: rt.Entry = _67; + const _82: rt.u64[] = rt.entryKey(v); + const _85: rt.u64[] = make(rt.u8Div(b, 2)); + rt.byteVecPush(out, rt.eqSlice(rt.u64Eq)(_82, _85) ? 1 : 0); + rt.entryOrInsertMut(v, i2); + } else { + const _76: rt.Place = rt.entryGetMut(_67); + _76.v = _76.v ^ 64; + } + } + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = 8; + while ((_95 = iterStart++) < iterEnd) { + const b2: rt.u8 = _95; + const key: rt.u64[] = make(b2); + const _104: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); + const _113: rt.u64[] = rt.sliceRange(key, 0); + const _109: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); + const _119: rt.u64[] = rt.sliceRange(key, 0); + const _115: rt.u8 = unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); + const _124: rt.u64[] = rt.sliceRange(key, 0); + const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; + const _129: rt.u64[] = rt.sliceRange(key, 0); + const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; + const _134: rt.u64[] = rt.sliceRange(key, 0); + const _131: rt.u8 = mapOr$0vfd25u(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.u64[], rt.u8]): rt.u8 => { + return rt.eqSlice(rt.u64Eq)(_2[0], key) ? 1 : 0; + }); + const _138: rt.u8 = mapOr$0vfd25u(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.u64[], rt.u8]): rt.u8 => { + const _5: rt.u64[] = rt.sliceRange(_22[0], 0); + const _63: rt.u64[] = rt.sliceRange(key, 0); + return rt.eqSlice(rt.u64Eq)(_5, _63) ? 1 : 0; + }); + const _147: rt.u64[] = rt.sliceRange(key, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, mapOr$0nlcxqx(rt.hashKey(set, _147), 221, (k: rt.u64[]): rt.u8 => { + return rt.eqSlice(rt.u64Eq)(k, key) ? 1 : 0; + }), mapOr$0nlcxqx(rt.hashGet(values, b2), 221, (v2: rt.u64[]): rt.u8 => { + return rt.eqSlice(rt.u64Eq)(v2, key) ? 1 : 0; + }))), undefined, true); + const _162: { end: rt.u64[] } = { end: copy$u64s(copy$u64s(key)) }; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); + const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.u64[]): rt.u8 => { + const order_ = rt.cmpSlice(rt.cmp)(k2, key); + return order_ !== undefined && order_ >= 0 ? 1 : 0; + }), rt.u8Add, 0)); + const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; + rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + } + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const keys_: rt.u64[][] = rt.iterToArray(rt.btreeKeys(ordered), undefined, 4, true); + const iter3: rt.Iter = rt.sliceWindows(keys_, 2); + while (true) { + const _206: rt.u64[][] | rt.Done = iter3.next(); + if (_206 === rt.DONE) { + break; + } + rt.idx(_206, 0); + rt.idx(_206, 1); + const _530: rt.u64[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + rt.idx(_206, 0); + const _531: rt.u64[] = _206[0]; + rt.idx(_206, 1); + const _532: rt.u64[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + rt.idx(_206, 0); + const _236: rt.u64[] = rt.sliceRange(_206[0], 0); + rt.idx(_206, 1); + const _240: rt.u64[] = rt.sliceRange(_206[1], 0); + rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rt.byteVecPush(out, mapOr$0vfd25u(rt.btreeFirst(tree), 221, (_24: [rt.u64[], rt.u8]): rt.u8 => { + const _83: rt.u64[] | undefined = _24[0]; + const _102: rt.u64[] | undefined = rt.sliceFirst(keys_); + return (rt.eqOption(rt.eqSlice(rt.u64Eq))(_83, _102) ? 1 : 0) ^ _24[1]; + })); + rt.byteVecPush(out, mapOr$0nlcxqx(rt.btreeFirstKey(ordered, true), 221, (k3: rt.u64[]): rt.u8 => { + const _57: rt.u64[] | undefined = k3; + const _84: rt.u64[] | undefined = rt.sliceLast(keys_); + return rt.eqOption(rt.eqSlice(rt.u64Eq))(_57, _84) ? 1 : 0; + })); + const part10 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const probe: rt.u64[] = make(part10); + const _268: rt.u64[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); + rt.byteVecPush(out, mapOr$0vfd25u(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.u64[], rt.u8]): rt.u8 => { + const k4: rt.u64[] = _26[0]; + const v3: rt.u8 = _26[1]; + return (rt.eqSlice(rt.u64Eq)(k4, probe) ? 1 : 0) ^ v3; + })); + const _281: rt.u64[] = rt.sliceRange(probe, 0); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); + const _288: rt.u64[] = rt.sliceRange(probe, 0); + const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; + const _293: rt.u64[] = rt.sliceRange(probe, 0); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rt.byteVecPush(out, mapOr$0nlcxqx(rt.btreePopKey(ordered), 221, (k5: rt.u64[]): rt.u8 => { + return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + })); + rt.btreeRetainMut(tree, (k6: rt.u64[], v4: rt.Place): boolean => { + const _512: rt.u64[] = rt.sliceRange(k6, 0); + const _611: rt.u64[] = rt.sliceRange(probe, 0); + const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + if (!((order2 !== undefined && order2 >= 0))) { + return rt.u8Rem(v4.v, 2) === 0; + } + return true; + }); + rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); + const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); + rt.byteSliceView(rt.byteVecSlice(held)).sort(); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + return n & 0xff; + })), undefined, true); + const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u64[] => { + return make(rt.u8Div(_29, 3)); + }); + const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 16, true); + const _335: [rt.u64[], rt.u8][] = [[copy$u64s(make(0)), 1] as [rt.u64[], rt.u8], [copy$u64s(make(1)), 2] as [rt.u64[], rt.u8]]; + const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 58720256); + for (const b3 of rt.byteSliceView(data)) { + const _354: rt.u64[] = rt.sliceRange(make(b3), 0); + rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); + const _361: rt.u64[] = rt.sliceRange(make(b3), 0); + const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + if (_359 === undefined) { + const _373: rt.u64[] = copy$u64s(make(b3)); + const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + return 0; + }); + _370.v = rt.u8Add(_370.v, 1); + } else { + _359.v = rt.u8WrappingMul(_359.v, 3); + } + } + const lent: [rt.u64[], rt.u8][] = rt.iterToArray(rt.hashIter(counts), "next", 8); + rt.sliceSort(lent, rt.cmpLt(rt.cmpTuple([rt.cmpSlice(rt.cmp), rt.cmp]))); + rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent), (_210: [rt.u64[], rt.u8]): rt.u8 => { + const k7: rt.u64[] = _210[0]; + const v5: rt.u8 = _210[1]; + return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); + rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rt.BTreeSet = rt.btreeClone(made, copy$u64s, undefined); + const _405: rt.u64[] = rt.sliceRange(probe, 0); + const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); + rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.u64[]): boolean => { + const _315: rt.u64[] = rt.sliceRange(k8, 0); + const _411: rt.u64[] = rt.sliceRange(probe, 0); + const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + return order3 !== undefined && order3 >= 0; + }) ? 1 : 0); + const pairs: rt.BTreeMap<[rt.u8, rt.u64[]], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.u64[]], rt.u8>; + const options_: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash64)), rt.eqOption(rt.eqSlice(rt.u64Eq)))) as rt.HashSet; + const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashMap; + const lists: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; + const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + while (true) { + const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); + if (_431 === rt.DONE) { + break; + } + const i3: rt.usize = _431[0]; + const b4: rt.u8 = _431[1]; + const _440: [rt.u8, rt.u64[]] = [rt.u8Rem(b4, 2), copy$u64s(make(b4))]; + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); + const _451: rt.u64[] | undefined = copy$Option_u64s(then$0uovwq9(rt.u8Rem(b4, 3) !== 0, (): rt.u64[] => { + return make(b4); + })); + rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); + const _462: rt.u64[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); + const _473: rt.u64[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + } + rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 8; + while ((_488 = iterStart2++) < iterEnd2) { + const key2: rt.u64[] = make(_488); + const _501: rt.u64[] | undefined = copy$u64s(key2); + const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; + const _508: rt.u64[] = rt.sliceRange(key2, 0); + const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); + const _513: rt.u64[] = rt.sliceRange(key2, 0); + const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; + const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + } + rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); +} + //# sourceMappingURL=keys.ts.map diff --git a/ts/fixtures/lang/expected/lib.ts b/ts/fixtures/lang/expected/lib.ts index c57a96d5e..3775161e7 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -94,6 +94,10 @@ export function copy$Hop(v: Hop.Hop): Hop.Hop { return { _0: v._0 }; } +export function copy$Hops(v: Hop.Hop[]): Hop.Hop[] { + return v.map(copy$Hop); +} + export function copy$Horizon(v: Horizon.Horizon): Horizon.Horizon { return { exclude: copy$Option_Hop(v.exclude), local: v.local }; } @@ -140,10 +144,18 @@ export function copy$Option_Hop(v: Hop.Hop | undefined): Hop.Hop | undefined { return v === undefined ? v : copy$Hop(v); } +export function copy$Option_Hops(v: Hop.Hop[] | undefined): Hop.Hop[] | undefined { + return v === undefined ? v : copy$Hops(v); +} + export function copy$Option_Mutex_u8_u8(v: [rt.Mutex, rt.u8] | undefined): [rt.Mutex, rt.u8] | undefined { return v === undefined ? v : copy$Mutex_u8_u8(v); } +export function copy$Option_Option_u8s(v: Array | undefined): Array | undefined { + return v === undefined ? v : copy$Option_u8s(v); +} + export function copy$Option_Pair(v: Pair.Pair | undefined): Pair.Pair | undefined { return v === undefined ? v : copy$Pair(v); } @@ -156,15 +168,35 @@ export function copy$Option_Tally(v: Tally.Tally | undefined): Tally.Tally | und return v === undefined ? v : copy$Tally(v); } +export function copy$Option_u16s(v: rt.u16[] | undefined): rt.u16[] | undefined { + return v === undefined ? v : copy$u16s(v); +} + +export function copy$Option_u32s(v: rt.u32[] | undefined): rt.u32[] | undefined { + return v === undefined ? v : copy$u32s(v); +} + +export function copy$Option_u32s$2(v: rt.u32[] | undefined): rt.u32[] | undefined { + return v === undefined ? v : copy$u32s(v); +} + export function copy$Option_u64_u64(v: [rt.u64, rt.u64] | undefined): [rt.u64, rt.u64] | undefined { return v === undefined ? v : copy$u64_u64(v); } +export function copy$Option_u64s(v: rt.u64[] | undefined): rt.u64[] | undefined { + return v === undefined ? v : copy$u64s(v); +} + export function copy$Option_u8_u8(v: [rt.u8, rt.u8] | undefined): [rt.u8, rt.u8] | undefined { return v === undefined ? v : copy$u8_u8(v); } -export function copy$Option_u8s(v: Uint8Array | undefined): Uint8Array | undefined { +export function copy$Option_u8s(v: Array): Array { + return v.slice(); +} + +export function copy$Option_u8s$2(v: Uint8Array | undefined): Uint8Array | undefined { return v === undefined ? v : copy$u8s(v); } @@ -238,6 +270,10 @@ export function copy$Wrap_u8(v: Wrap.Wrap): Wrap.Wrap { return new Wrap.Wrap(v.value, v.count); } +export function copy$u16s(v: rt.u16[]): rt.u16[] { + return v.slice(); +} + export function copy$u32_u32(v: [rt.u32, rt.u32]): [rt.u32, rt.u32] { return [v[0], v[1]]; } diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 92a1764db..5f8840e60 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -171,6 +171,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("arrays::lent", |_, data, out| arrays::lent(data, out)), ("floats::mul_adds", floats::mul_adds), ("singles::mul_adds", singles::mul_adds), + ("keys::arrays", keys::arrays), ] } diff --git a/ts/fixtures/lang/src/hints.rs b/ts/fixtures/lang/src/hints.rs index 19cb86ea3..bb92899c9 100644 --- a/ts/fixtures/lang/src/hints.rs +++ b/ts/fixtures/lang/src/hints.rs @@ -400,10 +400,11 @@ pub fn reserves(kind: u8, data: &[u8], out: &mut Vec) { }, out, ), + // Over 1024 bytes, which a `Vec` grows by as few as one of. _ => typed( kind, data, - |i| Big([i; 275]), + |i| [i; 275], Most { vec: 1_952_257, pairs: 1_945_184, @@ -415,10 +416,6 @@ pub fn reserves(kind: u8, data: &[u8], out: &mut Vec) { } } -/// Over 1024 bytes, which a `Vec` grows by as few as one of. -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -struct Big([u32; 275]); - /// Zero-sized, whose derived `clone` assigns nothing. #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] struct Unit; diff --git a/ts/fixtures/lang/src/keys.rs b/ts/fixtures/lang/src/keys.rs index 76fbdbfdc..809493cce 100644 --- a/ts/fixtures/lang/src/keys.rs +++ b/ts/fixtures/lang/src/keys.rs @@ -3,11 +3,13 @@ //! the references to values a map holds that JS copies, changed in place; and the `!=`, //! `<`, `<=`, `>`, and `>=` a type's `PartialEq` and `PartialOrd` inherit or override. //! Then bytes of each form, equal to one another and found by one another. +//! Then arrays of each element type as keys, found by the slices they borrow as. use std::borrow::Borrow; use std::cmp::{Ordering, Reverse}; use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, btree_map, hash_map}; use std::hash::{DefaultHasher, Hash, Hasher}; +use std::ops::Bound; use std::sync::Arc; /// A 64-bit hop, past 2^53 for some, where it is no longer a JS number. @@ -951,3 +953,127 @@ pub fn lent_values(kind: u8, data: &[u8], out: &mut Vec) { out.extend(v); } } + +/// Collections keyed by arrays of each element type, none at all, and many: found by an +/// equal array made apart and by the slice each borrows as, ordered as std orders arrays, +/// by their elements in turn, and ranged, walked, and edited through entries. A hash +/// collection's order is the runtime's, so what it yields is sorted first. +pub fn arrays(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 9 { + 0 => keyed(data, |b| [u16::from(b % 4) << 8, u16::from(b % 3)], out), + 1 => keyed(data, |b| [u64::MAX - u64::from(b % 4), 1 << (b % 3 * 30)], out), + 2 => keyed(data, |b| [i32::from(b as i8 % 3), -i32::from(b % 2)], out), + 3 => keyed(data, |b| ['\u{e000}', char::from(b % 4 + b'a')], out), + 4 => keyed(data, |b| [b % 2 == 0, b % 3 == 0], out), + 5 => keyed(data, |b| [small(b), small(b / 4)], out), + 6 => keyed(data, |b| [Hop(u64::from(b % 3) << 53), Hop(u64::from(b % 2))], out), + 7 => keyed(data, |_| [0u32; 0], out), + _ => keyed(data, |b| [u32::from(b % 4); 275], out), + } +} + +/// `arrays` of keys `make` makes of each byte. +fn keyed(data: &[u8], make: impl Fn(u8) -> [T; N], out: &mut Vec) { + let mut map: HashMap<[T; N], u8> = HashMap::new(); + let mut tree: BTreeMap<[T; N], u8> = BTreeMap::new(); + let mut set: HashSet<[T; N]> = HashSet::new(); + let mut ordered: BTreeSet<[T; N]> = BTreeSet::new(); + let mut values: HashMap = HashMap::new(); + for (i, &b) in data.iter().enumerate() { + let i = i as u8; + out.push(map.insert(make(b), i).unwrap_or(0xcc)); + out.push(tree.insert(make(b), i).unwrap_or(0xcc)); + out.extend([set.insert(make(b)) as u8, ordered.insert(make(b)) as u8]); + out.push(values.insert(b % 4, make(b)).map_or(0xcc, |old| (old == make(b)) as u8)); + *map.entry(make(b / 2)).or_insert(i) ^= 0x40; + match tree.entry(make(b / 2)) { + btree_map::Entry::Occupied(mut o) => *o.get_mut() ^= 0x40, + btree_map::Entry::Vacant(v) => { + out.push((*v.key() == make(b / 2)) as u8); + v.insert(i); + } + } + } + // Each found by an equal array made apart, and by the slice it borrows as. + for b in 0..8 { + let key = make(b); + out.extend([ + map.get(&key).copied().unwrap_or(0xdd), + map.get(&key[..]).copied().unwrap_or(0xdd), + tree.get(&key[..]).copied().unwrap_or(0xdd), + set.contains(&key[..]) as u8, + ordered.contains(&key[..]) as u8, + map.get_key_value(&key[..]).map_or(0xdd, |(k, _)| (*k == key) as u8), + tree.get_key_value(&key).map_or(0xdd, |(k, _)| (k[..] == key[..]) as u8), + set.get(&key[..]).map_or(0xdd, |k| (k == &key) as u8), + values.get(&b).map_or(0xdd, |v| (*v == key) as u8), + ]); + // Ranges by an array and by a slice, which order by the elements in turn. + out.push(tree.range(..key.clone()).count() as u8); + out.push(tree.range::<[T], _>((Bound::Excluded(&key[..]), Bound::Unbounded)).count() as u8); + out.push(ordered.range::<[T; N], _>(&key..).map(|k| (k >= &key) as u8).sum()); + out.push(ordered.range::<[T], _>((Bound::Unbounded, Bound::Included(&key[..]))).count() as u8); + } + // The order std gives arrays, read by the values each holds, and keys compared. + out.extend(tree.values().copied()); + let keys: Vec<&[T; N]> = ordered.iter().collect(); + for w in keys.windows(2) { + out.push((w[0] < w[1]) as u8 | ((w[0].cmp(w[1]) == w[0][..].cmp(&w[1][..])) as u8) << 1); + } + out.push(tree.first_key_value().map_or(0xdd, |(k, v)| (Some(k) == keys.first().copied()) as u8 ^ v)); + out.push(ordered.last().map_or(0xdd, |k| (Some(&k) == keys.last()) as u8)); + // Each removed by the slice it borrows as, then what is left. + let probe = make(data.first().copied().unwrap_or(0)); + out.push(map.remove(&probe[..]).unwrap_or(0xee)); + out.push(map.remove_entry(&probe).map_or(0xee, |(k, v)| (k == probe) as u8 ^ v)); + out.push(tree.remove(&probe[..]).unwrap_or(0xee)); + out.extend([set.remove(&probe[..]) as u8, ordered.remove(&probe[..]) as u8]); + out.push(ordered.pop_first().map_or(0xdd, |k| (k < probe) as u8)); + tree.retain(|k, v| k[..] >= probe[..] || *v % 2 == 0); + out.extend(tree.values().copied()); + let mut held: Vec = map.values().copied().collect(); + held.sort(); + out.extend(held); + out.extend([map.len(), tree.len(), set.len(), ordered.len()].map(|n| n as u8)); + // Collected, written through by a slice, split by one, and the keys lent sorted. + let made: BTreeSet<[T; N]> = data.iter().map(|&b| make(b / 3)).collect(); + let mut counts: HashMap<[T; N], u8> = HashMap::from([(make(0), 1), (make(1), 2)]); + for &b in data { + out.push(counts.contains_key(&make(b)[..]) as u8); + match counts.get_mut(&make(b)[..]) { + Some(c) => *c = c.wrapping_mul(3), + None => *counts.entry(make(b)).or_default() += 1, + } + } + let mut lent: Vec<(&[T; N], &u8)> = counts.iter().collect(); + lent.sort(); + out.extend(lent.iter().map(|&(k, v)| (made.contains(k) as u8) << 7 | v)); + out.push(made.intersection(&ordered).count() as u8); + out.push(made.is_subset(&ordered) as u8); + let mut upper = made.clone(); + let lower = upper.split_off(&probe[..]); + out.extend([upper.len() as u8, lower.len() as u8]); + out.push(lower.iter().all(|k| k[..] >= probe[..]) as u8); + // Keys that hold an array, and vectors found by the slice each borrows as. + let mut pairs: BTreeMap<(u8, [T; N]), u8> = BTreeMap::new(); + let mut options: HashSet> = HashSet::new(); + let mut vecs: HashMap, u8> = HashMap::new(); + let mut lists: BTreeSet> = BTreeSet::new(); + for (i, &b) in data.iter().enumerate() { + out.push(pairs.insert((b % 2, make(b)), i as u8).unwrap_or(0xcc)); + out.push(options.insert((b % 3 != 0).then(|| make(b))) as u8); + out.push(vecs.insert(make(b).to_vec(), i as u8).unwrap_or(0xcc)); + out.push(lists.insert(make(b / 2).to_vec()) as u8); + } + out.extend(pairs.values().copied()); + for b in 0..8 { + let key = make(b); + out.extend([ + options.contains(&Some(key.clone())) as u8, + vecs.get(&key[..]).copied().unwrap_or(0xdd), + lists.contains(&key[..]) as u8, + lists.range::<[T], _>((Bound::Included(&key[..]), Bound::Unbounded)).count() as u8, + ]); + } + out.push(options.contains(&None) as u8); +} diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index cb972ac3e..00c923f78 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -74,8 +74,11 @@ export function cmpStr(a: string, b: string): Ordering { /** * `Ord::cmp` of tuples, or `PartialOrd::partial_cmp`, from each field's: the first that - * is not `Equal`, as `None` is not. + * is not `Equal`, as `None` is not. A tuple type the call is asserted to compare types + * each field's function, which a generic one such as a slice's of `rt.cmp` needs. */ +export function cmpTuple(fields: { readonly [I in keyof T]: (a: T[I], b: T[I]) => O }): (a: T, b: T) => O; +export function cmpTuple(fields: readonly ((a: never, b: never) => O)[]): (a: T, b: T) => O; export function cmpTuple(fields: readonly ((a: never, b: never) => O)[]): (a: T, b: T) => O { return (a, b) => { for (let i = 0; i < fields.length; i++) { @@ -364,8 +367,11 @@ export interface HashMap { /** `HashSet`. */ export type HashSet = HashMap; -/** `HashMap::new` and `HashSet::new`, with how to find a key that is an object. */ -export function hashNew(h?: Hashing): HashMap { +/** + * `HashMap::new` and `HashSet::new`, with how to find a key that is an object. The type + * `K` is asserted, not inferred from `h`: a slice's hashing takes any `ArrayLike`. + */ +export function hashNew(h?: Hashing>): HashMap { return { p: new Map(), o: undefined, n: 0, h }; } @@ -967,8 +973,11 @@ function leaf(k: K[] = [], v: V[] = []): Leaf { return { k, v, prev: undefined, next: undefined }; } -/** `BTreeMap::new` and `BTreeSet::new`, ordered by `cmp`. */ -export function btreeNew(cmp: (a: K, b: K) => Ordering): BTreeMap { +/** + * `BTreeMap::new` and `BTreeSet::new`, ordered by `cmp`. The type `K` is asserted, not + * inferred from `cmp`: a slice's order takes any `ArrayLike`. + */ +export function btreeNew(cmp: (a: NoInfer, b: NoInfer) => Ordering): BTreeMap { return { t: leaf(), h: 0, n: 0, c: cmp, r: false }; } diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index c0b038bed..0c7733cbe 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -175,10 +175,10 @@ pub fn call<'tcx>( *at = Expr::rt("byteSliceView", vec![std::mem::replace(at, Expr::undefined())]); } } - // Bytes of any form hash and compare alike, so each finds the others. - let alike = |key: Ty<'tcx>, by: Ty<'tcx>| same_key(b, key, by) || (bytes(b, peel(b, key)) && bytes(b, peel(b, by))); + // Elements of any form, an array, a slice, or a `Vec`, hash and compare alike, so each + // finds the others. if let Some(by) = by - && !alike(arg(coll, 0), by) + && !alike(b, arg(coll, 0), by) { // An `Arc`'s `Hash`, `Eq`, and `Ord` are its value's, so the value it is looked up by // stands in as an `Arc` of it, which the collection only compares. From 5bb42e63e2f0355545dd31ad910ba7ee2111f8f9 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 16:38:01 -0700 Subject: [PATCH 3/5] test(ts): compare tuples holding array keys, and drop the finished quest Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 1 - quest/m3/ts-array-keys.md | 15 - ts/README.md | 6 +- ts/fixtures/lang/expected/keys.ts | 471 ++++++++++++++++-------------- ts/fixtures/lang/src/keys.rs | 4 +- 5 files changed, 264 insertions(+), 233 deletions(-) delete mode 100644 quest/m3/ts-array-keys.md diff --git a/quest/m3/README.md b/quest/m3/README.md index 6f53e6e56..37897e3a1 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -33,5 +33,4 @@ generic std gap is planned here even when moq never calls it. - [A VecDeque's Debug](/quest/m3/ts-deque-debug.md) - `{:?}` of a `VecDeque` translates, writing std's list - [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 - [std's impls of its zero-sized types](/quest/m3/ts-zero-sized-impls.md) - `PhantomData`'s derived impls translate, and `()` is a hash or B-tree key -- [Array keys a collection holds](/quest/m3/ts-array-keys.md) - collections of `[T; N]` keys type-check - [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 diff --git a/quest/m3/ts-array-keys.md b/quest/m3/ts-array-keys.md deleted file mode 100644 index 1b7748459..000000000 --- a/quest/m3/ts-array-keys.md +++ /dev/null @@ -1,15 +0,0 @@ -# [S] Array keys a collection holds - -## Goal - -rust2-ts translates a `HashMap`, `HashSet`, `BTreeMap`, or `BTreeSet` of `[T; N]` keys -to TypeScript `tsc` accepts, proven by a differential test against native Rust. - -## Plan - -Found by `hints.rs` in the lang fixture: a collection of `[u32; 275]` keys casts its -`rt.cmpSlice` collection of `ArrayLike` keys to one of `u32[]`, which `tsc` rejects. Its -`[u8; 3]` items, collected in a function generic over them, refuse as -[ts-byte-refs-taken](/quest/m3/ts-byte-refs-taken.md) describes. - -Public API: the translator's output. diff --git a/ts/README.md b/ts/README.md index 608626388..9e4c50f47 100644 --- a/ts/README.md +++ b/ts/README.md @@ -296,9 +296,9 @@ number, string, or boolean in a JS `Map`, which compares those as Rust's `Eq` do finds any other key, a 64-bit one past 2^53 included, through its translated `Hash` and `Eq`; a B-tree orders every key by its translated `Ord`. std's impls are the runtime's: an `Option` orders `None` first, an `Arc` compares, orders, and hashes as what it holds, -so a map of `Arc` finds a `&str`, and byte arrays, slices, and vectors order by their -bytes and then their length, and compare and hash alike whatever their form, so a map of -`Vec` finds a `&[u8]`. A collection's reference to a byte array it holds, as `keys`, +so a map of `Arc` finds a `&str`, and arrays, slices, and vectors, of bytes or of +other elements, order by their elements and then their length, and compare and hash alike +whatever their form, so a map of `Vec` finds a `&[u8]` and one of `[u16; 2]` a `&[u16]`. A collection's reference to a byte array it holds, as `keys`, `HashSet::get`, and `retain`'s closure get one, is an `rt.ByteSlice` of its bytes, as a `&[u8; N]` is elsewhere; a `&mut` writes where the collection holds them. A `&mut` to a value a map holds that JS copies, such as a number, from `get_mut` or the entry API, is an `rt.Place` whose `v` reads and diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index ee8537373..55d3fbd74 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1639,7 +1639,7 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { /** `arrays` of keys `make` makes of each byte. */ export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8) => Hop.Hop[], out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$PartialEq))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(Hop.cmp$Ord)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$PartialEq))) as rt.HashSet; @@ -1734,13 +1734,13 @@ export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: Hop.Hop[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(Hop.partialCmp$PartialOrd)(_206[0], _530) === -1 ? 1 : 0; + const _555: Hop.Hop[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(Hop.partialCmp$PartialOrd)(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: Hop.Hop[] = _206[0]; + const _556: Hop.Hop[] = _206[0]; rt.idx(_206, 1); - const _532: Hop.Hop[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(Hop.cmp$Ord)(_531, _532); + const _557: Hop.Hop[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(Hop.cmp$Ord)(_556, _557); rt.idx(_206, 0); const _236: Hop.Hop[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -1843,30 +1843,35 @@ export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8 } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, Hop.Hop[]] = [rt.u8Rem(b4, 2), copy$Hops(make(b4))]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: Hop.Hop[] | undefined = copy$Option_Hops(then$1c9ust9(rt.u8Rem(b4, 3) !== 0, (): Hop.Hop[] => { + const pair: [rt.u8, Hop.Hop[]] = [rt.u8Rem(b4, 2), copy$Hops(make(b4))]; + const _452: [rt.u8, Hop.Hop[]] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(Hop.partialCmp$PartialOrd)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, Hop.Hop[]] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(Hop.partialCmp$PartialOrd)])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: Hop.Hop[] | undefined = copy$Option_Hops(then$1c9ust9(rt.u8Rem(b4, 3) !== 0, (): Hop.Hop[] => { return make(b4); })); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: Hop.Hop[] = make(b4).map(copy$Hop); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: Hop.Hop[] = make(rt.u8Div(b4, 2)).map(copy$Hop); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: Hop.Hop[] = make(b4).map(copy$Hop); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: Hop.Hop[] = make(rt.u8Div(b4, 2)).map(copy$Hop); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: Hop.Hop[] = make(_488); - const _501: Hop.Hop[] | undefined = copy$Hops(key2); - const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; - const _508: Hop.Hop[] = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: Hop.Hop[] = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: Hop.Hop[] = make(_513); + const _526: Hop.Hop[] | undefined = copy$Hops(key2); + const _522: rt.u8 = rt.hashContains(options_, _526) ? 1 : 0; + const _533: Hop.Hop[] = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: Hop.Hop[] = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } @@ -1874,7 +1879,7 @@ export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8 /** `arrays` of keys `make` makes of each byte. */ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: rt.u8) => Array, out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; const tree: rt.BTreeMap, rt.u8> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeMap, rt.u8>; const set: rt.HashSet> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashSet>; @@ -1969,13 +1974,13 @@ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: Array = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_206[0], _530) === -1 ? 1 : 0; + const _555: Array = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: Array = _206[0]; + const _556: Array = _206[0]; rt.idx(_206, 1); - const _532: Array = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmpOption(rt.cmp))(_531, _532); + const _557: Array = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmpOption(rt.cmp))(_556, _557); rt.idx(_206, 0); const _236: Array = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -2078,30 +2083,35 @@ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, Array] = [rt.u8Rem(b4, 2), copy$Option_u8s(make(b4))]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: Array | undefined = copy$Option_Option_u8s(then$0b2eeh4(rt.u8Rem(b4, 3) !== 0, (): Array => { + const pair: [rt.u8, Array] = [rt.u8Rem(b4, 2), copy$Option_u8s(make(b4))]; + const _452: [rt.u8, Array] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmpOption(rt.cmp))])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, Array] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmpOption(rt.cmp))])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: Array | undefined = copy$Option_Option_u8s(then$0b2eeh4(rt.u8Rem(b4, 3) !== 0, (): Array => { return make(b4); })); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: Array = make(b4).slice(); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: Array = make(rt.u8Div(b4, 2)).slice(); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: Array = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: Array = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: Array = make(_488); - const _501: Array | undefined = copy$Option_u8s(key2); - const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; - const _508: Array = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: Array = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound>, { tag: "Unbounded" } as rt.RangeBound>]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: Array = make(_513); + const _526: Array | undefined = copy$Option_u8s(key2); + const _522: rt.u8 = rt.hashContains(options_, _526) ? 1 : 0; + const _533: Array = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: Array = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound>, { tag: "Unbounded" } as rt.RangeBound>]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } @@ -2109,7 +2119,7 @@ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: /** `arrays` of keys `make` makes of each byte. */ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u8) => boolean[], out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2204,13 +2214,13 @@ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: boolean[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + const _555: boolean[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: boolean[] = _206[0]; + const _556: boolean[] = _206[0]; rt.idx(_206, 1); - const _532: boolean[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + const _557: boolean[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); rt.idx(_206, 0); const _236: boolean[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -2313,29 +2323,34 @@ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, boolean[]] = [rt.u8Rem(b4, 2), make(b4)]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: boolean[] | undefined = then$1ghn4qd(rt.u8Rem(b4, 3) !== 0, (): boolean[] => { + const pair: [rt.u8, boolean[]] = [rt.u8Rem(b4, 2), make(b4)]; + const _452: [rt.u8, boolean[]] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, boolean[]] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: boolean[] | undefined = then$1ghn4qd(rt.u8Rem(b4, 3) !== 0, (): boolean[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: boolean[] = make(b4).slice(); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: boolean[] = make(rt.u8Div(b4, 2)).slice(); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: boolean[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: boolean[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: boolean[] = make(_488); - const _497: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; - const _508: boolean[] = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: boolean[] = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: boolean[] = make(_513); + const _522: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; + const _533: boolean[] = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: boolean[] = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } @@ -2343,7 +2358,7 @@ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u /** `arrays` of keys `make` makes of each byte. */ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u8) => rt.char[], out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2438,13 +2453,13 @@ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: rt.char[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + const _555: rt.char[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: rt.char[] = _206[0]; + const _556: rt.char[] = _206[0]; rt.idx(_206, 1); - const _532: rt.char[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + const _557: rt.char[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); rt.idx(_206, 0); const _236: rt.char[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -2547,29 +2562,34 @@ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, rt.char[]] = [rt.u8Rem(b4, 2), make(b4)]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: rt.char[] | undefined = then$1dhbcvy(rt.u8Rem(b4, 3) !== 0, (): rt.char[] => { + const pair: [rt.u8, rt.char[]] = [rt.u8Rem(b4, 2), make(b4)]; + const _452: [rt.u8, rt.char[]] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, rt.char[]] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rt.char[] | undefined = then$1dhbcvy(rt.u8Rem(b4, 3) !== 0, (): rt.char[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: rt.char[] = make(b4).slice(); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: rt.char[] = make(rt.u8Div(b4, 2)).slice(); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: rt.char[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rt.char[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: rt.char[] = make(_488); - const _497: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; - const _508: rt.char[] = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: rt.char[] = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: rt.char[] = make(_513); + const _522: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; + const _533: rt.char[] = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: rt.char[] = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } @@ -2577,7 +2597,7 @@ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u /** `arrays` of keys `make` makes of each byte. */ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8) => rt.i32[], out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2672,13 +2692,13 @@ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: rt.i32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + const _555: rt.i32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: rt.i32[] = _206[0]; + const _556: rt.i32[] = _206[0]; rt.idx(_206, 1); - const _532: rt.i32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + const _557: rt.i32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); rt.idx(_206, 0); const _236: rt.i32[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -2781,29 +2801,34 @@ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8 } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, rt.i32[]] = [rt.u8Rem(b4, 2), make(b4)]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: rt.i32[] | undefined = then$1nf265w(rt.u8Rem(b4, 3) !== 0, (): rt.i32[] => { + const pair: [rt.u8, rt.i32[]] = [rt.u8Rem(b4, 2), make(b4)]; + const _452: [rt.u8, rt.i32[]] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, rt.i32[]] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rt.i32[] | undefined = then$1nf265w(rt.u8Rem(b4, 3) !== 0, (): rt.i32[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: rt.i32[] = make(b4).slice(); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: rt.i32[] = make(rt.u8Div(b4, 2)).slice(); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: rt.i32[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rt.i32[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: rt.i32[] = make(_488); - const _497: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; - const _508: rt.i32[] = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: rt.i32[] = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: rt.i32[] = make(_513); + const _522: rt.u8 = rt.hashContains(options_, key2) ? 1 : 0; + const _533: rt.i32[] = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: rt.i32[] = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } @@ -2811,7 +2836,7 @@ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8 /** `arrays` of keys `make` makes of each byte. */ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16[], out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2906,13 +2931,13 @@ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: rt.u16[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + const _555: rt.u16[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: rt.u16[] = _206[0]; + const _556: rt.u16[] = _206[0]; rt.idx(_206, 1); - const _532: rt.u16[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + const _557: rt.u16[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); rt.idx(_206, 0); const _236: rt.u16[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -3015,30 +3040,35 @@ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8 } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, rt.u16[]] = [rt.u8Rem(b4, 2), copy$u16s(make(b4))]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: rt.u16[] | undefined = copy$Option_u16s(then$0l07w38(rt.u8Rem(b4, 3) !== 0, (): rt.u16[] => { + const pair: [rt.u8, rt.u16[]] = [rt.u8Rem(b4, 2), copy$u16s(make(b4))]; + const _452: [rt.u8, rt.u16[]] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, rt.u16[]] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rt.u16[] | undefined = copy$Option_u16s(then$0l07w38(rt.u8Rem(b4, 3) !== 0, (): rt.u16[] => { return make(b4); })); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: rt.u16[] = make(b4).slice(); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: rt.u16[] = make(rt.u8Div(b4, 2)).slice(); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: rt.u16[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rt.u16[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: rt.u16[] = make(_488); - const _501: rt.u16[] | undefined = copy$u16s(key2); - const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; - const _508: rt.u16[] = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: rt.u16[] = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: rt.u16[] = make(_513); + const _526: rt.u16[] | undefined = copy$u16s(key2); + const _522: rt.u8 = rt.hashContains(options_, _526) ? 1 : 0; + const _533: rt.u16[] = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: rt.u16[] = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } @@ -3046,7 +3076,7 @@ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8 /** `arrays` of keys `make` makes of each byte. */ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -3141,13 +3171,13 @@ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: rt.u32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + const _555: rt.u32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: rt.u32[] = _206[0]; + const _556: rt.u32[] = _206[0]; rt.idx(_206, 1); - const _532: rt.u32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + const _557: rt.u32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); rt.idx(_206, 0); const _236: rt.u32[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -3250,30 +3280,35 @@ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8 } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, rt.u32[]] = [rt.u8Rem(b4, 2), copy$u32s(make(b4))]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: rt.u32[] | undefined = copy$Option_u32s(then$0l8o6jo(rt.u8Rem(b4, 3) !== 0, (): rt.u32[] => { + const pair: [rt.u8, rt.u32[]] = [rt.u8Rem(b4, 2), copy$u32s(make(b4))]; + const _452: [rt.u8, rt.u32[]] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, rt.u32[]] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rt.u32[] | undefined = copy$Option_u32s(then$0l8o6jo(rt.u8Rem(b4, 3) !== 0, (): rt.u32[] => { return make(b4); })); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: rt.u32[] = make(b4).slice(); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: rt.u32[] = make(rt.u8Div(b4, 2)).slice(); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: rt.u32[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rt.u32[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: rt.u32[] = make(_488); - const _501: rt.u32[] | undefined = copy$u32s(key2); - const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; - const _508: rt.u32[] = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: rt.u32[] = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: rt.u32[] = make(_513); + const _526: rt.u32[] | undefined = copy$u32s(key2); + const _522: rt.u8 = rt.hashContains(options_, _526) ? 1 : 0; + const _533: rt.u32[] = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: rt.u32[] = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } @@ -3281,7 +3316,7 @@ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8 /** `arrays` of keys `make` makes of each byte. */ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -3376,13 +3411,13 @@ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt. } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: rt.u32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + const _555: rt.u32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: rt.u32[] = _206[0]; + const _556: rt.u32[] = _206[0]; rt.idx(_206, 1); - const _532: rt.u32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + const _557: rt.u32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); rt.idx(_206, 0); const _236: rt.u32[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -3485,30 +3520,35 @@ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt. } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, rt.u32[]] = [rt.u8Rem(b4, 2), copy$u32s(make(b4))]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: rt.u32[] | undefined = copy$Option_u32s$2(then$0l8o6jo(rt.u8Rem(b4, 3) !== 0, (): rt.u32[] => { + const pair: [rt.u8, rt.u32[]] = [rt.u8Rem(b4, 2), copy$u32s(make(b4))]; + const _452: [rt.u8, rt.u32[]] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, rt.u32[]] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rt.u32[] | undefined = copy$Option_u32s$2(then$0l8o6jo(rt.u8Rem(b4, 3) !== 0, (): rt.u32[] => { return make(b4); })); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: rt.u32[] = make(b4).slice(); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: rt.u32[] = make(rt.u8Div(b4, 2)).slice(); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: rt.u32[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rt.u32[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: rt.u32[] = make(_488); - const _501: rt.u32[] | undefined = copy$u32s(key2); - const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; - const _508: rt.u32[] = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: rt.u32[] = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: rt.u32[] = make(_513); + const _526: rt.u32[] | undefined = copy$u32s(key2); + const _522: rt.u8 = rt.hashContains(options_, _526) ? 1 : 0; + const _533: rt.u32[] = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: rt.u32[] = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } @@ -3516,7 +3556,7 @@ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt. /** `arrays` of keys `make` makes of each byte. */ export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { let _95!: rt.u8; - let _488!: rt.u8; + let _513!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashSet; @@ -3611,13 +3651,13 @@ export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _530: rt.u64[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _530) === -1 ? 1 : 0; + const _555: rt.u64[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; rt.idx(_206, 0); - const _531: rt.u64[] = _206[0]; + const _556: rt.u64[] = _206[0]; rt.idx(_206, 1); - const _532: rt.u64[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_531, _532); + const _557: rt.u64[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); rt.idx(_206, 0); const _236: rt.u64[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -3720,30 +3760,35 @@ export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8 } const i3: rt.usize = _431[0]; const b4: rt.u8 = _431[1]; - const _440: [rt.u8, rt.u64[]] = [rt.u8Rem(b4, 2), copy$u64s(make(b4))]; - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, _440, i3 & 0xff), 204)); - const _451: rt.u64[] | undefined = copy$Option_u64s(then$0uovwq9(rt.u8Rem(b4, 3) !== 0, (): rt.u64[] => { + const pair: [rt.u8, rt.u64[]] = [rt.u8Rem(b4, 2), copy$u64s(make(b4))]; + const _452: [rt.u8, rt.u64[]] = [1, make(2)]; + const _444: rt.u8 = ((rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rt.u8, rt.u64[]] = [0, make(3)]; + const order4 = rt.cmpTuple([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); + rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rt.u64[] | undefined = copy$Option_u64s(then$0uovwq9(rt.u8Rem(b4, 3) !== 0, (): rt.u64[] => { return make(b4); })); - rt.byteVecPush(out, rt.hashAdd(options_, _451) ? 1 : 0); - const _462: rt.u64[] = make(b4).slice(); - rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _462, i3 & 0xff), 204)); - const _473: rt.u64[] = make(rt.u8Div(b4, 2)).slice(); - rt.byteVecPush(out, rt.btreeAdd(lists, _473) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(options_, _476) ? 1 : 0); + const _487: rt.u64[] = make(b4).slice(); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rt.u64[] = make(rt.u8Div(b4, 2)).slice(); + rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); } rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 8; - while ((_488 = iterStart2++) < iterEnd2) { - const key2: rt.u64[] = make(_488); - const _501: rt.u64[] | undefined = copy$u64s(key2); - const _497: rt.u8 = rt.hashContains(options_, _501) ? 1 : 0; - const _508: rt.u64[] = rt.sliceRange(key2, 0); - const _504: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _508), 221); - const _513: rt.u64[] = rt.sliceRange(key2, 0); - const _510: rt.u8 = rt.btreeContains(lists, _513) ? 1 : 0; - const _519: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_497, _504, _510, rt.iterCount(rt.btreeRangeKeys(lists, _519)) & 0xff)), undefined, true); + while ((_513 = iterStart2++) < iterEnd2) { + const key2: rt.u64[] = make(_513); + const _526: rt.u64[] | undefined = copy$u64s(key2); + const _522: rt.u8 = rt.hashContains(options_, _526) ? 1 : 0; + const _533: rt.u64[] = rt.sliceRange(key2, 0); + const _529: rt.u8 = unwrapOr$0r2bmpr(rt.hashGet(vecs, _533), 221); + const _538: rt.u64[] = rt.sliceRange(key2, 0); + const _535: rt.u8 = rt.btreeContains(lists, _538) ? 1 : 0; + const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); } diff --git a/ts/fixtures/lang/src/keys.rs b/ts/fixtures/lang/src/keys.rs index 809493cce..e3628cecb 100644 --- a/ts/fixtures/lang/src/keys.rs +++ b/ts/fixtures/lang/src/keys.rs @@ -1060,7 +1060,9 @@ fn keyed(data: &[u8], make: impl Fn(u8) - let mut vecs: HashMap, u8> = HashMap::new(); let mut lists: BTreeSet> = BTreeSet::new(); for (i, &b) in data.iter().enumerate() { - out.push(pairs.insert((b % 2, make(b)), i as u8).unwrap_or(0xcc)); + let pair = (b % 2, make(b)); + out.push(((&pair < &(1, make(2))) as u8) << 1 | (pair <= (0, make(3))) as u8); + out.push(pairs.insert(pair, i as u8).unwrap_or(0xcc)); out.push(options.insert((b % 3 != 0).then(|| make(b))) as u8); out.push(vecs.insert(make(b).to_vec(), i as u8).unwrap_or(0xcc)); out.push(lists.insert(make(b / 2).to_vec()) as u8); From 1add123a0ec2aec58a6886ccc6963588f85a7b78 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 16:45:39 -0700 Subject: [PATCH 4/5] style(ts): format the array keys fixture Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/src/keys.rs | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/ts/fixtures/lang/src/keys.rs b/ts/fixtures/lang/src/keys.rs index e3628cecb..3c71598bb 100644 --- a/ts/fixtures/lang/src/keys.rs +++ b/ts/fixtures/lang/src/keys.rs @@ -1010,9 +1010,16 @@ fn keyed(data: &[u8], make: impl Fn(u8) - ]); // Ranges by an array and by a slice, which order by the elements in turn. out.push(tree.range(..key.clone()).count() as u8); - out.push(tree.range::<[T], _>((Bound::Excluded(&key[..]), Bound::Unbounded)).count() as u8); + out.push( + tree.range::<[T], _>((Bound::Excluded(&key[..]), Bound::Unbounded)) + .count() as u8, + ); out.push(ordered.range::<[T; N], _>(&key..).map(|k| (k >= &key) as u8).sum()); - out.push(ordered.range::<[T], _>((Bound::Unbounded, Bound::Included(&key[..]))).count() as u8); + out.push( + ordered + .range::<[T], _>((Bound::Unbounded, Bound::Included(&key[..]))) + .count() as u8, + ); } // The order std gives arrays, read by the values each holds, and keys compared. out.extend(tree.values().copied()); @@ -1020,7 +1027,10 @@ fn keyed(data: &[u8], make: impl Fn(u8) - for w in keys.windows(2) { out.push((w[0] < w[1]) as u8 | ((w[0].cmp(w[1]) == w[0][..].cmp(&w[1][..])) as u8) << 1); } - out.push(tree.first_key_value().map_or(0xdd, |(k, v)| (Some(k) == keys.first().copied()) as u8 ^ v)); + out.push( + tree.first_key_value() + .map_or(0xdd, |(k, v)| (Some(k) == keys.first().copied()) as u8 ^ v), + ); out.push(ordered.last().map_or(0xdd, |k| (Some(&k) == keys.last()) as u8)); // Each removed by the slice it borrows as, then what is left. let probe = make(data.first().copied().unwrap_or(0)); @@ -1074,7 +1084,9 @@ fn keyed(data: &[u8], make: impl Fn(u8) - options.contains(&Some(key.clone())) as u8, vecs.get(&key[..]).copied().unwrap_or(0xdd), lists.contains(&key[..]) as u8, - lists.range::<[T], _>((Bound::Included(&key[..]), Bound::Unbounded)).count() as u8, + lists + .range::<[T], _>((Bound::Included(&key[..]), Bound::Unbounded)) + .count() as u8, ]); } out.push(options.contains(&None) as u8); From 4460cb2e9d3addf7d2d8c2994b6e476742b1fab6 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 17:22:26 -0700 Subject: [PATCH 5/5] fix(ts): find a reference key by its pointee again, and plan unbounded ranges as iterators Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 1 + quest/m3/ts-range-from-iter.md | 16 ++ ts/fixtures/lang/expected/keys.ts | 254 ++++++++++++++++++++++++------ ts/fixtures/lang/src/keys.rs | 9 ++ ts/src/lower/collections.rs | 9 +- 5 files changed, 240 insertions(+), 49 deletions(-) create mode 100644 quest/m3/ts-range-from-iter.md diff --git a/quest/m3/README.md b/quest/m3/README.md index 529de7dc4..43448cd89 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -34,3 +34,4 @@ generic std gap is planned here even when moq never calls it. - [LinkedList](/quest/m3/ts-linked-list.md) - `LinkedList` and its methods translate - [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 diff --git a/quest/m3/ts-range-from-iter.md b/quest/m3/ts-range-from-iter.md new file mode 100644 index 000000000..8146842e8 --- /dev/null +++ b/quest/m3/ts-range-from-iter.md @@ -0,0 +1,16 @@ +# [S] Unbounded ranges as iterators adaptors take + +## Goal + +An unbounded `start..` that an adaptor takes as its `IntoIterator`, as `iter.zip(0..)` +does, translates to an iterator `tsc` accepts, proven by a differential test against +native Rust, including where `start` reaches its type's maximum. + +## Plan + +Found by `keys::arrays` in the lang fixture: `firsts.iter().zip(0..)` translates to +`rt.iterZip(rt.iterSlice(firsts), { start: 0 })`, which `tsc` rejects, since the range's +struct reaches `iterZip` in place of an `rt.Iter`. Audit every adaptor that takes an +`IntoIterator` (`zip`, `chain`, `extend`, `eq`, `cmp`) for the same. + +Public API: the translator's output. diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 55d3fbd74..73666dbec 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$Hop, copy$Hops, copy$Horizon, copy$Option_Hops, copy$Option_Option_u8s, copy$Option_u16s, copy$Option_u32s, copy$Option_u32s$2, copy$Option_u64s, copy$Option_u8s, copy$Option_u8s$2, copy$u16s, copy$u32s, copy$u64s, copy$u8_Horizon, copy$u8s, drop$u8_Reverse_Arc_Lopsided } from "./lib.ts"; +import { copy$Hop, copy$Hops, copy$Horizon, copy$Option_Hop, copy$Option_Hops, copy$Option_Option_u8s, copy$Option_u16s, copy$Option_u32s, copy$Option_u32s$2, copy$Option_u64s, copy$Option_u8s, copy$Option_u8s$2, copy$u16s, copy$u32s, copy$u64s, copy$u8_Horizon, copy$u8s, drop$u8_Reverse_Arc_Lopsided } from "./lib.ts"; import { thenSome$0rsp0eu, then$1c9ust9, then$0b2eeh4, then$18np55d, then$1ghn4qd, then$1dhbcvy, then$1nf265w, then$0l07w38, then$0l8o6jo, then$0uovwq9 } from "./core/bool.ts"; import { unwrapOr$1tvry1i, unwrapOr$1j4op5y, unwrapOr$0r2bmpr, map$120lney, map$146awhd, map$0lcwx9x, map$0gn4nwv, mapOr$04khdaj, mapOr$0rtxftk, mapOr$0spovx0, mapOr$1bumeih, mapOr$187k0x1, mapOr$1dgdmlk, mapOr$1kiffmd, mapOr$1a3irjf, mapOr$0qqhf4e, mapOr$13q9j26, mapOr$141aobk, mapOr$1afbbm4, mapOr$17y4wkx, mapOr$03mkmku, mapOr$0iyypgq, mapOr$1h1mlmc, mapOr$1xwgm12, mapOr$0nlcxqx, mapOr$0vfd25u, mapOr$1surhce, mapOr$1w1gbwl, mapOr$1be3nsj, mapOr$0z7fb2w, mapOr$02k4ito } from "./core/option.ts"; import * as Hop from "./keys.Hop.ts"; @@ -1640,6 +1640,7 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8) => Hop.Hop[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$PartialEq))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(Hop.cmp$Ord)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$PartialEq))) as rt.HashSet; @@ -1734,13 +1735,13 @@ export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: Hop.Hop[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(Hop.partialCmp$PartialOrd)(_206[0], _555) === -1 ? 1 : 0; + const _594: Hop.Hop[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(Hop.partialCmp$PartialOrd)(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: Hop.Hop[] = _206[0]; + const _595: Hop.Hop[] = _206[0]; rt.idx(_206, 1); - const _557: Hop.Hop[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(Hop.cmp$Ord)(_556, _557); + const _596: Hop.Hop[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(Hop.cmp$Ord)(_595, _596); rt.idx(_206, 0); const _236: Hop.Hop[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -1874,12 +1875,30 @@ export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8 rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: Hop.Hop[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): Hop.Hop | undefined => { + return copy$Option_Hop(rt.sliceFirst(make(_215))); + }), "next", 8); + const _560: rt.Iter<[Hop.Hop, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, Hop.Hop]): [Hop.Hop, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [Hop.Hop, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(Hop.cmp$Ord) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined, Hop.eq$PartialEq)) as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: Hop.Hop | undefined = rt.sliceFirst(make(_572)); + if (_576 !== undefined) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } /** `arrays` of keys `make` makes of each byte. */ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: rt.u8) => Array, out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; const tree: rt.BTreeMap, rt.u8> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeMap, rt.u8>; const set: rt.HashSet> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashSet>; @@ -1974,13 +1993,13 @@ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: Array = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_206[0], _555) === -1 ? 1 : 0; + const _594: Array = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: Array = _206[0]; + const _595: Array = _206[0]; rt.idx(_206, 1); - const _557: Array = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmpOption(rt.cmp))(_556, _557); + const _596: Array = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmpOption(rt.cmp))(_595, _596); rt.idx(_206, 0); const _236: Array = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -2114,12 +2133,30 @@ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: Array = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u8 | undefined | rt.None => { + return rt.sliceFirst(make(_215), rt.None); + }, rt.None), "next", 2); + const _560: rt.Iter<[rt.u8 | undefined, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u8 | undefined]): [rt.u8 | undefined, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [rt.u8 | undefined, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: rt.u8 | undefined | rt.None = rt.sliceFirst(make(_572), rt.None); + if (_576 !== rt.None) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } /** `arrays` of keys `make` makes of each byte. */ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u8) => boolean[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2214,13 +2251,13 @@ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: boolean[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; + const _594: boolean[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: boolean[] = _206[0]; + const _595: boolean[] = _206[0]; rt.idx(_206, 1); - const _557: boolean[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); + const _596: boolean[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); rt.idx(_206, 0); const _236: boolean[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -2353,12 +2390,30 @@ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: boolean[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): boolean | undefined => { + return rt.sliceFirst(make(_215)); + }), "next", 1); + const _560: rt.Iter<[boolean, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, boolean]): [boolean, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [boolean, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: boolean | undefined = rt.sliceFirst(make(_572)); + if (_576 !== undefined) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } /** `arrays` of keys `make` makes of each byte. */ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u8) => rt.char[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2453,13 +2508,13 @@ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: rt.char[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; + const _594: rt.char[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: rt.char[] = _206[0]; + const _595: rt.char[] = _206[0]; rt.idx(_206, 1); - const _557: rt.char[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); + const _596: rt.char[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); rt.idx(_206, 0); const _236: rt.char[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -2592,12 +2647,30 @@ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.char | undefined => { + return rt.sliceFirst(make(_215)); + }), "next", 4); + const _560: rt.Iter<[rt.char, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.char]): [rt.char, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [rt.char, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: rt.char | undefined = rt.sliceFirst(make(_572)); + if (_576 !== undefined) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } /** `arrays` of keys `make` makes of each byte. */ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8) => rt.i32[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2692,13 +2765,13 @@ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: rt.i32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; + const _594: rt.i32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: rt.i32[] = _206[0]; + const _595: rt.i32[] = _206[0]; rt.idx(_206, 1); - const _557: rt.i32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); + const _596: rt.i32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); rt.idx(_206, 0); const _236: rt.i32[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -2831,12 +2904,30 @@ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8 rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: rt.i32[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.i32 | undefined => { + return rt.sliceFirst(make(_215)); + }), "next", 4); + const _560: rt.Iter<[rt.i32, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.i32]): [rt.i32, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [rt.i32, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: rt.i32 | undefined = rt.sliceFirst(make(_572)); + if (_576 !== undefined) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } /** `arrays` of keys `make` makes of each byte. */ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash16), rt.eqSlice(rt.same))) as rt.HashSet; @@ -2931,13 +3022,13 @@ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: rt.u16[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; + const _594: rt.u16[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: rt.u16[] = _206[0]; + const _595: rt.u16[] = _206[0]; rt.idx(_206, 1); - const _557: rt.u16[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); + const _596: rt.u16[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); rt.idx(_206, 0); const _236: rt.u16[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -3071,12 +3162,30 @@ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8 rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: rt.u16[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u16 | undefined => { + return rt.sliceFirst(make(_215)); + }), "next", 2); + const _560: rt.Iter<[rt.u16, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u16]): [rt.u16, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [rt.u16, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: rt.u16 | undefined = rt.sliceFirst(make(_572)); + if (_576 !== undefined) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } /** `arrays` of keys `make` makes of each byte. */ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -3171,13 +3280,13 @@ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: rt.u32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; + const _594: rt.u32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: rt.u32[] = _206[0]; + const _595: rt.u32[] = _206[0]; rt.idx(_206, 1); - const _557: rt.u32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); + const _596: rt.u32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); rt.idx(_206, 0); const _236: rt.u32[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -3311,12 +3420,30 @@ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8 rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: rt.u32[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u32 | undefined => { + return rt.sliceFirst(make(_215)); + }), "next", 4); + const _560: rt.Iter<[rt.u32, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u32]): [rt.u32, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [rt.u32, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: rt.u32 | undefined = rt.sliceFirst(make(_572)); + if (_576 !== undefined) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } /** `arrays` of keys `make` makes of each byte. */ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; @@ -3411,13 +3538,13 @@ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt. } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: rt.u32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; + const _594: rt.u32[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: rt.u32[] = _206[0]; + const _595: rt.u32[] = _206[0]; rt.idx(_206, 1); - const _557: rt.u32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); + const _596: rt.u32[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); rt.idx(_206, 0); const _236: rt.u32[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -3551,12 +3678,30 @@ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt. rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: rt.u32[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u32 | undefined => { + return rt.sliceFirst(make(_215)); + }), "next", 4); + const _560: rt.Iter<[rt.u32, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u32]): [rt.u32, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [rt.u32, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: rt.u32 | undefined = rt.sliceFirst(make(_572)); + if (_576 !== undefined) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } /** `arrays` of keys `make` makes of each byte. */ export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { let _95!: rt.u8; let _513!: rt.u8; + let _572!: rt.u8; const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash64), rt.eqSlice(rt.u64Eq))) as rt.HashSet; @@ -3651,13 +3796,13 @@ export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8 } rt.idx(_206, 0); rt.idx(_206, 1); - const _555: rt.u64[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _555) === -1 ? 1 : 0; + const _594: rt.u64[] = _206[1]; + const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; rt.idx(_206, 0); - const _556: rt.u64[] = _206[0]; + const _595: rt.u64[] = _206[0]; rt.idx(_206, 1); - const _557: rt.u64[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_556, _557); + const _596: rt.u64[] = _206[1]; + const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); rt.idx(_206, 0); const _236: rt.u64[] = rt.sliceRange(_206[0], 0); rt.idx(_206, 1); @@ -3791,6 +3936,23 @@ export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8 rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, _544)) & 0xff)), undefined, true); } rt.byteVecPush(out, rt.hashContains(options_, undefined) ? 1 : 0); + const firsts: rt.u64[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u64 | undefined => { + return rt.sliceFirst(make(_215)); + }), "next", 8); + const _560: rt.Iter<[rt.u64, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u64]): [rt.u64, rt.u8] => { + return [_218[1], _218[0] & 0xff] as [rt.u64, rt.u8]; + }); + const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rt.Iter = rt.iterSlice(firsts); + const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_572 = iterStart3++) < iterEnd3) { + const _576: rt.u64 | undefined = rt.sliceFirst(make(_572)); + if (_576 !== undefined) { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + } + } } //# sourceMappingURL=keys.ts.map diff --git a/ts/fixtures/lang/src/keys.rs b/ts/fixtures/lang/src/keys.rs index 3c71598bb..e7187819b 100644 --- a/ts/fixtures/lang/src/keys.rs +++ b/ts/fixtures/lang/src/keys.rs @@ -1090,4 +1090,13 @@ fn keyed(data: &[u8], make: impl Fn(u8) - ]); } out.push(options.contains(&None) as u8); + // Keys that are references to elements, found by what each points at. + let firsts: Vec = data.iter().filter_map(|&b| make(b).first().cloned()).collect(); + let refs: BTreeMap<&T, u8> = firsts.iter().enumerate().map(|(i, k)| (k, i as u8)).collect(); + let hashed: HashSet<&T> = firsts.iter().collect(); + for b in 0..8 { + if let Some(first) = make(b).first() { + out.extend([refs.get(first).copied().unwrap_or(0xdd), hashed.contains(first) as u8]); + } + } } diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index a1ce937dd..9a5e59dab 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -182,13 +182,16 @@ pub fn call<'tcx>( } } // Elements of any form, an array, a slice, or a `Vec`, hash and compare alike, so each - // finds the others. + // finds the others. A reference key finds what it points at by that value's own impls, + // whatever `alike` makes of its `PartialEq` against a reference. if let Some(by) = by - && !alike(b, arg(coll, 0), by) + && let key = arg(coll, 0) + && !same_key(b, key, by) + && !alike(b, key, by) { // An `Arc`'s `Hash`, `Eq`, and `Ord` are its value's, so the value it is looked up by // stands in as an `Arc` of it, which the collection only compares. - let arc = arc_of(b, peel(b, arg(coll, 0))).is_some_and(|inner| same_key(b, inner, by)); + let arc = arc_of(b, peel(b, key)).is_some_and(|inner| same_key(b, inner, by)); match args.get_mut(1) { Some(key) if arc && !matches!(name, "range" | "range_mut") => { let value = std::mem::replace(key, Expr::undefined());