diff --git a/quest/m2/ts-mir-size.md b/quest/m2/ts-mir-size.md index d14cf2f8f..31228f4e8 100644 --- a/quest/m2/ts-mir-size.md +++ b/quest/m2/ts-mir-size.md @@ -8,22 +8,32 @@ bytes minified and 9422 gzipped, and the async handoff's at most 10949 and 3458. ## Plan -The codec's bundle is 30000 bytes minified and 9540 gzipped (+1.3% gzipped), and the -async handoff's 15119 and 3757 (+38%, +8.6%), against THIR's numbers above, built from +The codec's bundle is 29852 bytes minified and 9503 gzipped (+0.9% gzipped), and the +async handoff's 15053 and 3712 (+37%, +7.3%), against THIR's numbers above, built from the same fixtures. Each candidate is measured on the bench's sizes and timings before -it lands: - -- A coroutine's class, about 360 bytes minified each against about 140 for a THIR - generator, for the drop, the checks for a resume after it finished, and the - `try`/`catch` that poisons it and drops what it holds on a panic, where a THIR - generator had a `finally` and the runtime's one `Async` class: a base class in the - runtime for that scaffolding, or one field for saved locals that are never live at - once (the layout's `storage_conflicts`). Each is timed in Chrome, which decides, with - the bundle minified, since what a `poll` compiles to decides how many levels V8 - inlines: private fields cost Node 24 5% at depth 16 that way. Generators and closures - stay out: they measured 1.4-5.5x and 1.3-1.8x slower on the handoff. -- The handoff's code outside the classes, about 140 bytes gzipped over THIR's. -- The codec's `fill`, `encodeFrames`, and `decodeSplit`, whose blocks nest deeper than - THIR's loops did. +it lands. + +The handoff's two gaps have different sources: + +- Minified, nearly all of it is the fixture's 16 one-await `levelN` classes, about 360 + bytes each against about 135 for a THIR generator and its wrapper. Gzip folds the + copies: the 15 repeats cost 172 bytes gzipped, less than THIR's 201. +- Gzipped, the gap is the code outside the repeats: with one level each, MIR's bundle is + 284 bytes gzipped over THIR's. `drainFuture`'s `switch` dispatch, `recvFuture`, and + `register` and `wake`, whose `for` loops are stepped `while` loops with temporaries, + are where it is. + +Tried and dropped: + +- A runtime base class for the scaffolding (the resume-after-finish checks and the + poisoning `catch`), with `resume` per class so its calls stay monomorphic: prototyped + by hand on the 17 one-await classes, 792 bytes smaller minified but 38 larger gzipped. + A base can't read a subclass's `#state`, so only those two pieces move. +- Collapsing an `async fn` whose body only awaits another that only moves its arguments + in (`level2` into `level1` and on): exact, but it removes the depth the handoff + measures, and moq-net's wrappers await `kio::wait`, not such an `async fn`. + +Generators and closures stay out: they measured 1.4-5.5x and 1.3-1.8x slower on the +handoff. Coroutine fields stay private. Public API: the translator's output, which changes shape but not behavior. diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 5d3ee3ac7..c86f146fd 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -68,16 +68,13 @@ export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVe const w: Encoder.Encoder = Encoder.new(out, form_); let iterStart: rt.usize = 0; const iterEnd: rt.usize = rt.u64Low(count); - l0: while (true) { - if (!(iterStart++ < iterEnd)) { - return rt.Ok(undefined); - } + while (iterStart++ < iterEnd) { const _17: rt.Result = Encoder.varint(w, value); - if (_17.ok) { - continue l0; + if (!_17.ok) { + return _17; } - return _17; } + return rt.Ok(undefined); } /** Every varint on the wire: how many, and the last. */ @@ -85,20 +82,18 @@ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVe const r: Decoder.Decoder = Decoder.new(wire, form_); let count: rt.usize = 0; let last: rt.u64 = 0; - l0: while (true) { - if (!Decoder.isEmpty(r)) { - const _9: rt.Result = Decoder.varint(r); - if (_9.ok) { - last = _9.value; - count = rt.usizeAdd(count, 1); - continue l0; - } + while (!Decoder.isEmpty(r)) { + const _9: rt.Result = Decoder.varint(r); + if (_9.ok) { + last = _9.value; + count = rt.usizeAdd(count, 1); + } else { return _9; } - putUsize(out, count); - putU64(out, last); - return rt.Ok(undefined); } + putUsize(out, count); + putU64(out, last); + return rt.Ok(undefined); } /** @@ -127,11 +122,8 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt const w: Encoder.Encoder = Encoder.new(out, Form.from$From_Version(version)); let iterStart: rt.usize = 0; const iterEnd: rt.usize = rt.u64Low(count); - l0: while (true) { - if (!((_32 = iterStart++) < iterEnd)) { - return rt.Ok(undefined); - } - b2: { + while ((_32 = iterStart++) < iterEnd) { + b3: { const n: rt.usize = _32; if (n === 0) { _38 = [0, first] as [rt.i64, rt.u64]; @@ -139,7 +131,7 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt if (keyEvery2 !== 0) { if (rt.usizeRem(n, keyEvery2) === 0) { _38 = [delta2, keySize] as [rt.i64, rt.u64]; - break b2; + break b3; } } _38 = [delta2, size] as [rt.i64, rt.u64]; @@ -151,13 +143,14 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt const _45: rt.Result = Encoder.varint(w, _48); if (_45.ok) { const _51: rt.Result = Encoder.varint(w, size2); - if (_51.ok) { - continue l0; + if (!_51.ok) { + return _51; } - return _51; + } else { + return _45; } - return _45; } + return rt.Ok(undefined); } /** Every FRAME header on the wire: how many, their total size, and the last delta. */ @@ -166,26 +159,25 @@ export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt let count: rt.usize = 0; let total: rt.u64 = 0; let last: rt.i64 = 0; - l0: while (true) { - if (!Decoder.isEmpty(r)) { - const _12: rt.Result = Decoder.varint(r); - if (_12.ok) { - last = unzigzag(_12.value); - const _18: rt.Result = Decoder.varint(r); - if (_18.ok) { - total = rt.u64Add(total, _18.value); - count = rt.usizeAdd(count, 1); - continue l0; - } + while (!Decoder.isEmpty(r)) { + const _12: rt.Result = Decoder.varint(r); + if (_12.ok) { + last = unzigzag(_12.value); + const _18: rt.Result = Decoder.varint(r); + if (_18.ok) { + total = rt.u64Add(total, _18.value); + count = rt.usizeAdd(count, 1); + } else { return _18; } + } else { return _12; } - putUsize(out, count); - putU64(out, total); - putU64(out, rt.u64Cast(last)); - return rt.Ok(undefined); } + putUsize(out, count); + putU64(out, total); + putU64(out, rt.u64Cast(last)); + return rt.Ok(undefined); } /** @@ -204,21 +196,11 @@ export function decodeSplit(data: Uint8Array, version: Version.Version, out: rt. let total: rt.u64 = 0; let last: rt.i64 = 0; let short: rt.usize = 0; - l0: while (true) { - if (!(end < _6[1].length)) { - if (!(start < end)) { - putUsize(out, count); - putU64(out, total); - putU64(out, rt.u64Cast(last)); - putUsize(out, short); - return rt.Ok(undefined); - } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); - } + l2: while (end < _6[1].length) { end = rt.min(_6[1].length, rt.usizeAdd(end, read2)); while (true) { if (!(start < end)) { - continue l0; + continue l2; } const slice = _6[1]; const r: Decoder.Decoder = Decoder.new(rt.sliceRange(slice, start, end), Form.from$From_Version(version)); @@ -233,13 +215,21 @@ export function decodeSplit(data: Uint8Array, version: Version.Version, out: rt. } else { if (_32.error.tag === "Short") { short = rt.usizeAdd(short, 1); - continue l0; + continue l2; } const _0: rt.Result = rt.Err(_32.error); return _0; } } } + if (!(start < end)) { + putUsize(out, count); + putU64(out, total); + putU64(out, rt.u64Cast(last)); + putUsize(out, short); + return rt.Ok(undefined); + } + return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } /** One FRAME header: the zigzag timestamp delta, then the size. */ @@ -280,43 +270,37 @@ export function ordered(data: Uint8Array, out: rt.ByteVec): void { const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; let iterStart: rt.u32 = 0; const iterEnd: rt.u32 = count2; - while (true) { - if (!((_15 = iterStart++) < iterEnd)) { - let sum: rt.u64 = 0; - let iterStart2: rt.u32 = 0; - const iterEnd2: rt.u32 = count2; - while (true) { - if (!((_28 = iterStart2++) < iterEnd2)) { - const _49: rt.Range = new rt.Range(1 << 14, 2 << 14); - const iter3: rt.Iter<[rt.u32, rt.u32]> = rt.btreeRange(map, _49); - while (true) { - const _57: [rt.u32, rt.u32] | rt.Done = iter3.next(); - if (_57 === rt.DONE) { - let iterStart3: rt.u32 = 0; - const iterEnd3: rt.u32 = count2; - while (true) { - if (!((_66 = iterStart3++) < iterEnd3)) { - putU64(out, sum); - return; - } - const _73: rt.u32 = _10(_66); - rt.btreeRemove(map, _73); - } - } - sum = rt.u64Add(sum, _57[1] as rt.u64); - } - } - const i2: rt.u32 = _28; - const _42: rt.u32 = rt.u32Sub(count2, 1); - const part = rt.u32Sub(_42, i2); - const _38: rt.u32 = _10(part); - sum = rt.u64Add(sum, rt.optionUnwrapOr(rt.btreeGet(map, _38), 0) as rt.u64); - } - } + while ((_15 = iterStart++) < iterEnd) { const i: rt.u32 = _15; const _21: rt.u32 = _10(i); rt.btreeInsert(map, _21, i); } + let sum: rt.u64 = 0; + let iterStart2: rt.u32 = 0; + const iterEnd2: rt.u32 = count2; + while ((_28 = iterStart2++) < iterEnd2) { + const i2: rt.u32 = _28; + const _42: rt.u32 = rt.u32Sub(count2, 1); + const part = rt.u32Sub(_42, i2); + const _38: rt.u32 = _10(part); + sum = rt.u64Add(sum, rt.optionUnwrapOr(rt.btreeGet(map, _38), 0) as rt.u64); + } + const _49: rt.Range = new rt.Range(1 << 14, 2 << 14); + const iter3: rt.Iter<[rt.u32, rt.u32]> = rt.btreeRange(map, _49); + while (true) { + const _57: [rt.u32, rt.u32] | rt.Done = iter3.next(); + if (_57 === rt.DONE) { + break; + } + sum = rt.u64Add(sum, _57[1] as rt.u64); + } + let iterStart3: rt.u32 = 0; + const iterEnd3: rt.u32 = count2; + while ((_66 = iterStart3++) < iterEnd3) { + const _73: rt.u32 = _10(_66); + rt.btreeRemove(map, _73); + } + putU64(out, sum); } /** @@ -324,45 +308,43 @@ export function ordered(data: Uint8Array, out: rt.ByteVec): void { * next to the iterator protocol they run through. */ export function iterate(chain: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - b0: { - if (chain === 0) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (_211: rt.u8): rt.u8 => { - return _211 >> 1; - }), (_212: rt.u8): boolean => { - return (_212 & 1) === 0; - }))); - } else if (chain === 1) { - const _11: rt.Iter = rt.iterSlice(data); - rt.byteVecPush(out, rt.iterAny(_11, (_210: rt.u8): boolean => { - return _210 === 255; - }) ? 1 : 0); - } else if (chain === 2) { - putUsize(out, rt.iterToByteVec(rt.iterFilter(rt.iterSlice(data), (_28: rt.u8): boolean => { - return (_28 & 1) === 1; - })).length); - } else if (chain === 3) { - putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u32 => { - return _2 as rt.u32; - }), rt.u32Add, 0) as rt.u64); - } else if (chain === 4) { - putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(data), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { - return (acc ^ _3 as rt.u32) >>> 0; - }) as rt.u64); - } else { - let last: rt.usize = 0; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); - while (true) { - const _33: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_33 === rt.DONE) { - putUsize(out, last); - break b0; - } - const i: rt.usize = _33[0]; - if (_33[1] === 128) { - last = i; - } + if (chain === 0) { + putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (_211: rt.u8): rt.u8 => { + return _211 >> 1; + }), (_212: rt.u8): boolean => { + return (_212 & 1) === 0; + }))); + } else if (chain === 1) { + const _11: rt.Iter = rt.iterSlice(data); + rt.byteVecPush(out, rt.iterAny(_11, (_210: rt.u8): boolean => { + return _210 === 255; + }) ? 1 : 0); + } else if (chain === 2) { + putUsize(out, rt.iterToByteVec(rt.iterFilter(rt.iterSlice(data), (_28: rt.u8): boolean => { + return (_28 & 1) === 1; + })).length); + } else if (chain === 3) { + putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u32 => { + return _2 as rt.u32; + }), rt.u32Add, 0) as rt.u64); + } else if (chain === 4) { + putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(data), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { + return (acc ^ _3 as rt.u32) >>> 0; + }) as rt.u64); + } else { + let last: rt.usize = 0; + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); + while (true) { + const _33: [rt.usize, rt.u8] | rt.Done = iter.next(); + if (_33 === rt.DONE) { + break; + } + const i: rt.usize = _33[0]; + if (_33[1] === 128) { + last = i; } } + putUsize(out, last); } } @@ -388,14 +370,8 @@ export function rescale(selector: rt.u8, data: Uint8Array, out: rt.ByteVec): voi let last: rt.u64 = 0; let iterStart: rt.usize = 0; const iterEnd: rt.usize = rt.u64Low(count); - while (true) { - if (!((_26 = iterStart++) < iterEnd)) { - putU64(out, converted); - putU64(out, overflowed); - putU64(out, last); - return; - } - b1: { + while ((_26 = iterStart++) < iterEnd) { + b2: { const value: rt.u64 = rt.u64Add(start, rt.u64Mul(_26 as rt.u64, step)); if (selector === 0) { const _36: rt.u128 | undefined = rt.u128CheckedMul(rt.u128Cast(value), rt.u128Cast(to)); @@ -411,7 +387,7 @@ export function rescale(selector: rt.u8, data: Uint8Array, out: rt.ByteVec): voi if (_44 !== undefined) { if (rt.u64Le(_44, rt.u64Of(2305843009213693951n))) { scaled = _44; - break b1; + break b2; } } scaled = undefined; @@ -424,6 +400,9 @@ export function rescale(selector: rt.u8, data: Uint8Array, out: rt.ByteVec): voi converted = rt.u64Add(converted, 1); } } + putU64(out, converted); + putU64(out, overflowed); + putU64(out, last); } /** `value`, or `None` past [`MAX_TIMESTAMP`], as moq-net bounds a converted timestamp. */ diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index 6bcead63f..5fb89482a 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -36,7 +36,7 @@ export function decode$Decode_Form(r: Decoder.Decoder, version: Form.Form): rt.R while (true) { const _12: rt.u64 | rt.Done = iter.next(); if (_12 === rt.DONE) { - return rt.Ok({ _0: vs }); + break; } const _15: rt.Result = Version.decode$Decode_Form(r, version); if (_15.ok) { @@ -45,6 +45,7 @@ export function decode$Decode_Form(r: Decoder.Decoder, version: Form.Form): rt.R return _15; } } + return rt.Ok({ _0: vs }); } return _3; } @@ -58,13 +59,14 @@ export function encode$Encode_Form(self: Versions, w: Encoder.Encoder, version: while (true) { const _14: Version.Version | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_14 === rt.DONE) { - return rt.Ok(undefined); + break; } const _18: rt.Result = Version.encode$Encode_Form(_14, w, version); if (!_18.ok) { return _18; } } + return rt.Ok(undefined); } return _4; } @@ -78,13 +80,14 @@ export function encode$Encode_Version(self: Versions, w: Encoder.Encoder, versio while (true) { const _14: Version.Version | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_14 === rt.DONE) { - return rt.Ok(undefined); + break; } const _18: rt.Result = Version.encode$Encode_Version(_14, w, version); if (!_18.ok) { return _18; } } + return rt.Ok(undefined); } return _4; } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index e959b70eb..c41ff6f70 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -196,33 +196,32 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void */ export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); - b0: { - if (_5 !== undefined) { - const selector: rt.u8 = _5[0]; - const _9: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(_5[1]); - if (_9 !== undefined) { - const len: rt.u8 = _9[0]; - const _15: rt.usize = _9[1].length; - const _13: [Uint8Array, Uint8Array] = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); - const r: Decoder.Decoder = Decoder.new(_13[1], form(selector)); - const iterS: Uint8Array = _13[0]; - let iterI: number = 0; - l1: while (true) { - const _21: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_21 !== rt.DONE) { - const _26: rt.Result = decodeStep(r, _21, out); - if (_26.ok) { - rt.byteVecPush(out, 0); - putUsize(out, Decoder.remaining(r)); - continue l1; - } - decodeFailed(out, _26.error); - putUsize(out, Decoder.need(r)); - } - rt.byteVecPush(out, Decoder.isEmpty(r) ? 1 : 0); - break b0; + if (_5 !== undefined) { + const selector: rt.u8 = _5[0]; + const _9: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(_5[1]); + if (_9 !== undefined) { + const len: rt.u8 = _9[0]; + const _15: rt.usize = _9[1].length; + const _13: [Uint8Array, Uint8Array] = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); + const r: Decoder.Decoder = Decoder.new(_13[1], form(selector)); + const iterS: Uint8Array = _13[0]; + let iterI: number = 0; + while (true) { + const _21: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_21 === rt.DONE) { + break; + } + const _26: rt.Result = decodeStep(r, _21, out); + if (_26.ok) { + rt.byteVecPush(out, 0); + putUsize(out, Decoder.remaining(r)); + } else { + decodeFailed(out, _26.error); + putUsize(out, Decoder.need(r)); + break; } } + rt.byteVecPush(out, Decoder.isEmpty(r) ? 1 : 0); } } } @@ -319,106 +318,105 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { let _47!: rt.u64 | undefined; let _74!: Prefix.Prefix; const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); - b0: { - if (_5 !== undefined) { - const selector: rt.u8 = _5[0]; - const _9: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(_5[1]); - if (_9 !== undefined) { - const len: rt.u8 = _9[0]; - const _15: rt.usize = _9[1].length; - const _13: [Uint8Array, Uint8Array] = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); - let values: Uint8Array = _13[1]; - const buf: rt.ByteVec = new rt.ByteVec(); - const _20: Form.Form = form(selector); - const w: Encoder.Encoder = Encoder.new(buf, _20); - const prefixes: Prefix.Prefix[] = []; - const iterS: Uint8Array = _13[0]; - let iterI: number = 0; - while (true) { - const _24: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_24 === rt.DONE) { - while (true) { - const _98: Prefix.Prefix | undefined = prefixes.pop(); - if (_98 !== undefined) { - const _102: rt.Result = Encoder.fill(w, _98); - if (!_102.ok) { - encodeFailed(out, _102.error); - } - } else { - putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); - break b0; - } - } + if (_5 !== undefined) { + const selector: rt.u8 = _5[0]; + const _9: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(_5[1]); + if (_9 !== undefined) { + const len: rt.u8 = _9[0]; + const _15: rt.usize = _9[1].length; + const _13: [Uint8Array, Uint8Array] = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); + let values: Uint8Array = _13[1]; + const buf: rt.ByteVec = new rt.ByteVec(); + const _20: Form.Form = form(selector); + const w: Encoder.Encoder = Encoder.new(buf, _20); + const prefixes: Prefix.Prefix[] = []; + const iterS: Uint8Array = _13[0]; + let iterI: number = 0; + while (true) { + const _24: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_24 === rt.DONE) { + break; + } + const step: rt.u8 = _24; + const _30: [rt.u64, Uint8Array] = takeU64(values); + const value: rt.u64 = _30[0]; + values = _30[1]; + const _33: rt.u8 = rt.u8Rem(step, 10); + if (_33 === 0) { + Encoder.u8(w, rt.u64Low(value) & 0xff); + result = rt.Ok(undefined); + } else if (_33 === 1) { + Encoder.u16(w, rt.u64Low(value) & 0xffff); + result = rt.Ok(undefined); + } else if (_33 === 2) { + Encoder.bool(w, rt.u64And(value, 1) === 1); + result = rt.Ok(undefined); + } else if (_33 === 3) { + result = Encoder.varint(w, value); + } else if (_33 === 4) { + const _48: rt.u64 = rt.u64Rem(value, 3); + if (_48 === 0) { + _47 = undefined; + } else if (_48 === 1) { + _47 = value; + } else { + _47 = rt.u64Of(18446744073709551615n); } - const step: rt.u8 = _24; - const _30: [rt.u64, Uint8Array] = takeU64(values); - const value: rt.u64 = _30[0]; - values = _30[1]; - const _33: rt.u8 = rt.u8Rem(step, 10); - if (_33 === 0) { - Encoder.u8(w, rt.u64Low(value) & 0xff); - result = rt.Ok(undefined); - } else if (_33 === 1) { - Encoder.u16(w, rt.u64Low(value) & 0xffff); - result = rt.Ok(undefined); - } else if (_33 === 2) { - Encoder.bool(w, rt.u64And(value, 1) === 1); - result = rt.Ok(undefined); - } else if (_33 === 3) { - result = Encoder.varint(w, value); - } else if (_33 === 4) { - const _48: rt.u64 = rt.u64Rem(value, 3); - if (_48 === 0) { - _47 = undefined; - } else if (_48 === 1) { - _47 = value; - } else { - _47 = rt.u64Of(18446744073709551615n); - } - result = Encoder.varintOpt(w, _47); - } else if (_33 === 5) { - const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; - const _53: Uint8Array = rt.u64ToBeBytes(value); - const _51: Uint8Array = rt.sliceRange(_53, 0, part); - result = Encoder.bytes(w, _51); - } else if (_33 === 6) { - const _60: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(rt.u64ToBeBytes(value))); - if (_60.ok) { - const _68: string = _60.value; - result = Encoder.string(w, _68); - } else { - result = Encoder.string(w, "not utf-8"); - } - } else if (_33 === 7) { - if (rt.u64Rem(value, 2) === 0) { - _74 = Encoder.prefixVarint(w); - } else { - _74 = Encoder.prefixU16(w); - } - prefixes.push(_74); - result = rt.Ok(undefined); - } else if (_33 === 8) { - const _79: Prefix.Prefix | undefined = prefixes.pop(); - if (_79 === undefined) { - result = rt.Ok(undefined); - } else { - const prefix: Prefix.Prefix = _79; - putUsize(out, Encoder.since(w, prefix)); - result = Encoder.fill(w, prefix); - } + result = Encoder.varintOpt(w, _47); + } else if (_33 === 5) { + const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; + const _53: Uint8Array = rt.u64ToBeBytes(value); + const _51: Uint8Array = rt.sliceRange(_53, 0, part); + result = Encoder.bytes(w, _51); + } else if (_33 === 6) { + const _60: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(rt.u64ToBeBytes(value))); + if (_60.ok) { + const _68: string = _60.value; + result = Encoder.string(w, _68); + } else { + result = Encoder.string(w, "not utf-8"); + } + } else if (_33 === 7) { + if (rt.u64Rem(value, 2) === 0) { + _74 = Encoder.prefixVarint(w); } else { - const _88: Prefix.Prefix | undefined = prefixes.pop(); - if (_88 !== undefined) { - Encoder.discard(w, _88); - } + _74 = Encoder.prefixU16(w); + } + prefixes.push(_74); + result = rt.Ok(undefined); + } else if (_33 === 8) { + const _79: Prefix.Prefix | undefined = prefixes.pop(); + if (_79 === undefined) { result = rt.Ok(undefined); + } else { + const prefix: Prefix.Prefix = _79; + putUsize(out, Encoder.since(w, prefix)); + result = Encoder.fill(w, prefix); } - if (!result.ok) { - encodeFailed(out, result.error); + } else { + const _88: Prefix.Prefix | undefined = prefixes.pop(); + if (_88 !== undefined) { + Encoder.discard(w, _88); } + result = rt.Ok(undefined); + } + if (!result.ok) { + encodeFailed(out, result.error); } } + while (true) { + const _98: Prefix.Prefix | undefined = prefixes.pop(); + if (_98 !== undefined) { + const _102: rt.Result = Encoder.fill(w, _98); + if (!_102.ok) { + encodeFailed(out, _102.error); + } + } else { + break; + } + } + putUsize(out, buf.length); + rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); } } } @@ -436,10 +434,7 @@ export function sizes(data: Uint8Array, out: rt.ByteVec): void { const value: rt.u64 = takeU64(data)[0]; let iterStart: rt.u8 = 0; const iterEnd: rt.u8 = 3; - while (true) { - if (!((_9 = iterStart++) < iterEnd)) { - return; - } + while ((_9 = iterStart++) < iterEnd) { const _13: rt.Result = size(value, form(_9)); if (_13.ok) { putUsize(out, _13.value); diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index b45eeee08..fc03f783b 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -55,374 +55,311 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { Nibble.hash$Hash_DefaultHasher(n, h2); return rt.hashFinish(h2); }; - b0: { - const _4: rt.u8 = rt.u8Rem(kind, 4); - if (_4 === 0) { - const map: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2); - while (true) { - const _13: rt.usize | rt.Done = iter.next(); - if (_13 === rt.DONE) { - rt.byteVecPush(out, rt.hashLen(map) & 0xff); - rt.byteVecPush(out, rt.hashLen(map) === 0 ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterSum(rt.iterMap(rt.hashValues(map), (v5: rt.u16): rt.u16 => { - return rt.u16Rem(v5, 256); - }), rt.u16Add, 0))); - const _67: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashIter(map), (_227: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { - return [_227[0], _227[1]] as [rt.u8, rt.u16]; - }); - const iter2: rt.Iter<[rt.u8, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _67, true)); - while (true) { - const _73: [rt.u8, rt.u16] | rt.Done = iter2.next(); - if (_73 === rt.DONE) { - rt.hashClear(map); - rt.byteVecPush(out, rt.hashLen(map) & 0xff); - break b0; - } - rt.byteVecPush(out, _73[0]); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_73[1])); - } - } - const i: rt.usize = _13; - rt.idx(data, i); - const _19: [rt.u8, rt.u16] = [rt.u8Rem(data[i], 16), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0) as rt.u16]; - const k: rt.u8 = _19[0]; - const v: rt.u16 = _19[1]; - const _31: rt.u16 = rt.u16Rem(v, 5); - if (_31 === 0) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashRemove(map, k), 238, (old2: rt.u16): rt.u8 => { - return old2 & 0xff; - })); - } else if (_31 === 1) { - rt.byteVecPush(out, rt.hashContains(map, k) ? 1 : 0); - } else if (_31 === 2) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(map, k), 221, (v4: rt.u16): rt.u8 => { - return v4 & 0xff; - })); - } else { - const _48: rt.u16 = rt.u16Mul(v, 3); - rt.byteVecPush(out, rt.optionMapOr(rt.hashInsert(map, k, _48), 204, (old: rt.u16): rt.u8 => { - return old & 0xff; - })); - } + const _4: rt.u8 = rt.u8Rem(kind, 4); + if (_4 === 0) { + const map: rt.HashMap = rt.hashNew() as rt.HashMap; + const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2); + while (true) { + const _13: rt.usize | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13; + rt.idx(data, i); + const _19: [rt.u8, rt.u16] = [rt.u8Rem(data[i], 16), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0) as rt.u16]; + const k: rt.u8 = _19[0]; + const v: rt.u16 = _19[1]; + const _31: rt.u16 = rt.u16Rem(v, 5); + if (_31 === 0) { + rt.byteVecPush(out, rt.optionMapOr(rt.hashRemove(map, k), 238, (old2: rt.u16): rt.u8 => { + return old2 & 0xff; + })); + } else if (_31 === 1) { + rt.byteVecPush(out, rt.hashContains(map, k) ? 1 : 0); + } else if (_31 === 2) { + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(map, k), 221, (v4: rt.u16): rt.u8 => { + return v4 & 0xff; + })); + } else { + const _48: rt.u16 = rt.u16Mul(v, 3); + rt.byteVecPush(out, rt.optionMapOr(rt.hashInsert(map, k, _48), 204, (old: rt.u16): rt.u8 => { + return old & 0xff; + })); } } - if (_4 === 1) { - const map2: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInt, rt.u64Eq)) as rt.HashMap; - const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); - while (true) { - const _97: [rt.usize, rt.u8] | rt.Done = iter3.next(); - if (_97 === rt.DONE) { - const _123: rt.Iter = rt.hashKeys(map2); - const iter4: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _123, true)); - while (true) { - const _129: rt.u64 | rt.Done = iter4.next(); - if (_129 === rt.DONE) { - const _142: rt.u8 | undefined = rt.sliceFirst(data); - if (_142 !== undefined) { - const _150: rt.u64 = wide(rt.u8Rem(_142, 13)); - rt.byteVecPush(out, rt.hashIndex(map2, _150)); - } - break b0; - } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_129)); - rt.byteVecPush(out, rt.hashIndex(map2, _129)); - } - } - const i2: rt.usize = _97[0]; - const b: rt.u8 = _97[1]; - const k2: rt.u64 = wide(rt.u8Rem(b, 12)); - const _105: rt.u8 = rt.u8Rem(rt.u8Div(b, 12), 4); - if (_105 === 0) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashRemove(map2, k2), 238)); - } else if (_105 === 1) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashGet(map2, k2), 221)); - } else { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map2, k2, i2 & 0xff), 204)); - } + rt.byteVecPush(out, rt.hashLen(map) & 0xff); + rt.byteVecPush(out, rt.hashLen(map) === 0 ? 1 : 0); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterSum(rt.iterMap(rt.hashValues(map), (v5: rt.u16): rt.u16 => { + return rt.u16Rem(v5, 256); + }), rt.u16Add, 0))); + const _67: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashIter(map), (_227: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { + return [_227[0], _227[1]] as [rt.u8, rt.u16]; + }); + const iter2: rt.Iter<[rt.u8, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _67, true)); + while (true) { + const _73: [rt.u8, rt.u16] | rt.Done = iter2.next(); + if (_73 === rt.DONE) { + break; } + rt.byteVecPush(out, _73[0]); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_73[1])); } - if (_4 === 2) { - const map3: rt.HashMap = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashMap; - const pairs: rt.HashMap = rt.hashNew(rt.hashing(Pair.hash$Hash_DefaultHasher, Pair.eq$PartialEq)) as rt.HashMap; - const ranks: rt.HashMap = rt.hashNew(rt.hashing(Rank.hash$Hash_DefaultHasher, Rank.eq$PartialEq)) as rt.HashMap; - const tuples: rt.HashMap<[rt.u8, string], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashInt, rt.hashStr]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, string], rt.u8>; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; - while (true) { - if (!((_161 = iterStart++) < iterEnd)) { - const _225: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.hashIter(map3), (_214: [Nibble.Nibble, rt.u8]): [rt.u8, rt.u8] => { - return [_214[0]._0, _214[1]] as [rt.u8, rt.u8]; - }); - const iter6: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _225, true)); - while (true) { - const _230: [rt.u8, rt.u8] | rt.Done = iter6.next(); - if (_230 === rt.DONE) { - const key: Pair.Pair = { a: 9, b: 9 }; - const local: Tally.Tally = { n: 7 }; - rt.hashInsert(pairs, key, rt.copy(local)); - local.n = 8; - const before: Tally.Tally = rt.copy(rt.hashIndex(pairs, key)); - const _246: Tally.Tally | undefined = rt.hashGet(pairs, key); - if (_246 !== undefined) { - _246.n = rt.u16Add(_246.n, 2); - } - rt.byteVecPush(out, local.n & 0xff); - rt.byteVecPush(out, before.n & 0xff); - rt.byteVecPush(out, rt.hashIndex(pairs, key).n & 0xff); - const _265: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.hashIter(pairs); - const iter7: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, _265, true)); - while (true) { - const _269: [Pair.Pair, Tally.Tally] | rt.Done = iter7.next(); - if (_269 === rt.DONE) { - let iterStart2: rt.usize = 1; - const iterEnd2: rt.usize = data.length; - while (true) { - if (!((_286 = iterStart2++) < iterEnd2)) { - const copy: rt.HashMap = rt.hashClone(ranks, undefined, rt.copy); - const _327: Tally.Tally | undefined = rt.hashGet(copy, { tag: "Low" } as Rank.Rank); - if (_327 !== undefined) { - _327.n = 119; - } - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(ranks, { tag: "Low" } as Rank.Rank), 255, (t10: Tally.Tally): rt.u8 => { - return t10.n & 0xff; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(copy, { tag: "Low" } as Rank.Rank), 255, (t11: Tally.Tally): rt.u8 => { - return t11.n & 0xff; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.hashRemoveEntry(copy, { tag: "Mid", _0: 1 } as Rank.Rank), 255, (_218: [Rank.Rank, Tally.Tally]): rt.u8 => { - const k10: Rank.Rank = _218[0]; - const t12: Tally.Tally = _218[1]; - return rankByte(k10) ^ (t12.n & 0xff); - })); - const _348: rt.Iter<[rt.u8, Tally.Tally]> = rt.iterMap(rt.iterSlice(data), (_223: rt.u8): [rt.u8, Tally.Tally] => { - const b8: rt.u8 = _223; - return [rt.u8Rem(b8, 8), { n: b8 as rt.u16 }] as [rt.u8, Tally.Tally]; - }); - const bytes: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _348); - const copy2: rt.HashMap = rt.hashClone(bytes, undefined, rt.copy); - const iter9: rt.Iter = rt.hashValues(copy2); - while (true) { - const _356: Tally.Tally | rt.Done = iter9.next(); - if (_356 === rt.DONE) { - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; - while (true) { - if (!((_364 = iterStart3++) < iterEnd3)) { - const iterS: Uint8Array = data; - let iterI: number = 0; - while (true) { - const _380: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_380 === rt.DONE) { - const stamped: rt.HashMap = rt.hashNew() as rt.HashMap; - stamp(stamped); - stamp(stamped); - rt.byteVecPush(out, rt.hashLen(stamped) & 0xff); - const extended: rt.HashMap = rt.hashNew() as rt.HashMap; - rt.hashExtend(extended, rt.iterMap(rt.hashIter(bytes), rt.copy)); - const iter12: rt.Iter = rt.hashValues(extended); - while (true) { - const _409: Tally.Tally | rt.Done = iter12.next(); - if (_409 === rt.DONE) { - let iterStart4: rt.u8 = 0; - const iterEnd4: rt.u8 = 8; - while (true) { - if (!((_416 = iterStart4++) < iterEnd4)) { - const first: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - rt.byteVecPush(out, rt.u64Eq(_430({ _0: first }), _430({ _0: first ^ 240 })) ? 1 : 0); - const _448: [rt.Hasher, Tally.Tally] = [rt.hasher(), { n: first as rt.u16 }]; - const h: rt.Hasher = _448[0]; - const counted: Tally.Tally = rt.copy(_448[1]); - const _453: rt.Hasher = countedHasher(h, counted); - const _456: rt.u16 = counted.n; - rt.hashInt(_456, _453); - const want: rt.Hasher = rt.hasher(); - rt.hashInt(rt.u16Add(first as rt.u16, 1), want); - rt.byteVecPush(out, rt.u64Eq(rt.hashFinish(h), rt.hashFinish(want)) ? 1 : 0); - rt.hashRetain(ranks, (r2: Rank.Rank, t17: Tally.Tally): boolean => { - if (!(rt.u16Rem(t17.n, 2) === 0)) { - return Rank.eq$PartialEq(r2, { tag: "Low" } as Rank.Rank); - } - return true; - }); - const _473: rt.Iter<[Rank.Rank, rt.u16]> = rt.iterMap(rt.hashIter(ranks), (_224: [Rank.Rank, Tally.Tally]): [Rank.Rank, rt.u16] => { - return [_224[0], _224[1].n] as [Rank.Rank, rt.u16]; - }); - const iter14: rt.Iter<[Rank.Rank, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap, _473, true)); - while (true) { - const _479: [Rank.Rank, rt.u16] | rt.Done = iter14.next(); - if (_479 === rt.DONE) { - rt.byteVecPush(out, rt.hashLen(tuples) & 0xff); - break b0; - } - rt.byteVecPush(out, rankByte(_479[0])); - rt.byteVecPush(out, _479[1] & 0xff); - } - } - const k5: rt.u8 = _416; - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(bytes, k5), 255, (t15: Tally.Tally): rt.u8 => { - return t15.n & 0xff; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(extended, k5), 255, (t16: Tally.Tally): rt.u8 => { - return t16.n & 0xff; - })); - } - } - _409.n = _409.n ^ 17; - } - } - const b5: rt.u8 = _380; - const _387: rt.u8 = rt.u8Rem(b5, 8); - const _389: rt.u16 = b5 as rt.u16; - rt.byteVecPush(out, claim(copy2, _387, _389)); - } - } - const k4: rt.u8 = _364; - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(bytes, k4), 255, (t13: Tally.Tally): rt.u8 => { - return t13.n & 0xff; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(copy2, k4), 255, (t14: Tally.Tally): rt.u8 => { - return t14.n & 0xff; - })); - } - } - _356.n = rt.u16Add(_356.n, 1); - } - } - const i4: rt.usize = _286; - const _294: rt.usize = rt.usizeSub(i4, 1); - rt.idx(data, _294); - const _293: rt.u8 = data[_294]; - rt.idx(data, i4); - const _292: [rt.u8, rt.u8] = [_293, data[i4]]; - const a2: rt.u8 = _293; - const b4: rt.u8 = _292[1]; - const _305: Rank.Rank = rank(b4, a2); - const t4: Tally.Tally = rt.entryOrInsertWith(rt.entryAndModify(rt.entry(ranks, _305), (t9: Tally.Tally): void => { - t9.n = t9.n ^ 3; - }), (): Tally.Tally => { - return { n: b4 as rt.u16 }; - }); - t4.n = rt.u16WrappingAdd(t4.n, t4.n); - rt.idx(data, i4); - const _313: Rank.Rank = rank(data[i4], 0); - const e: rt.Entry = rt.entry(ranks, _313); - rt.byteVecPush(out, rankByte(rt.entryKey(e))); - rt.byteVecPush(out, rt.entryOrInsertWith(e, (k9: Rank.Rank): Tally.Tally => { - return { n: rankByte(k9) as rt.u16 }; - }).n & 0xff); - } - } - const p: Pair.Pair = _269[0]; - const t3: Tally.Tally = _269[1]; - rt.byteVecPush(out, p.a); - rt.byteVecPush(out, p.b & 0xff); - rt.byteVecPush(out, t3.n & 0xff); - } - } - const k3: rt.u8 = _230[0]; - const v2: rt.u8 = _230[1]; - rt.byteVecPush(out, k3); - rt.byteVecPush(out, v2); - } - } - const i3: rt.usize = _161; - const _169: rt.usize = rt.usizeSub(i3, 1); - rt.idx(data, _169); - const _168: rt.u8 = data[_169]; - rt.idx(data, i3); - const _167: [rt.u8, rt.u8] = [_168, data[i3]]; - const a: rt.u8 = _168; - const b3: rt.u8 = _167[1]; - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map3, { _0: a }, b3), 204)); - const pair: Pair.Pair = { a: rt.u8Rem(a, 4), b: rt.u16Rem(b3 as rt.u16, 3) }; - const t: Tally.Tally = rt.entryOrInsertWith(rt.entry(pairs, pair), Tally.default$Default); - t.n = rt.u16Add(t.n, 1); - const r: Rank.Rank = rank(a, b3); - const _192: Tally.Tally | undefined = rt.hashGet(ranks, r); - if (_192 !== undefined) { - _192.n = rt.u16Add(_192.n, 1); - } else { - rt.hashInsert(ranks, r, { n: i3 & 0xffff }); - } - const _203: rt.u8 = rt.u8Rem(a, 3); - const _207: rt.usize = rt.usizeRem(b3 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); - if (!(_207 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _207); - } - const t2: [rt.u8, string] = [_203, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_207]]; - rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashRemove(tuples, t2), 187)); - if (rt.u8Rem(a, 2) === 0) { - rt.hashInsert(tuples, t2, a); - } + rt.hashClear(map); + rt.byteVecPush(out, rt.hashLen(map) & 0xff); + } else if (_4 === 1) { + const map2: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInt, rt.u64Eq)) as rt.HashMap; + const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); + while (true) { + const _97: [rt.usize, rt.u8] | rt.Done = iter3.next(); + if (_97 === rt.DONE) { + break; } + const i2: rt.usize = _97[0]; + const b: rt.u8 = _97[1]; + const k2: rt.u64 = wide(rt.u8Rem(b, 12)); + const _105: rt.u8 = rt.u8Rem(rt.u8Div(b, 12), 4); + if (_105 === 0) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashRemove(map2, k2), 238)); + } else if (_105 === 1) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashGet(map2, k2), 221)); + } else { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map2, k2, i2 & 0xff), 204)); + } + } + const _123: rt.Iter = rt.hashKeys(map2); + const iter4: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _123, true)); + while (true) { + const _129: rt.u64 | rt.Done = iter4.next(); + if (_129 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_129)); + rt.byteVecPush(out, rt.hashIndex(map2, _129)); + } + const _142: rt.u8 | undefined = rt.sliceFirst(data); + if (_142 !== undefined) { + const _150: rt.u64 = wide(rt.u8Rem(_142, 13)); + rt.byteVecPush(out, rt.hashIndex(map2, _150)); } + } else if (_4 === 2) { + const map3: rt.HashMap = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashMap; + const pairs: rt.HashMap = rt.hashNew(rt.hashing(Pair.hash$Hash_DefaultHasher, Pair.eq$PartialEq)) as rt.HashMap; + const ranks: rt.HashMap = rt.hashNew(rt.hashing(Rank.hash$Hash_DefaultHasher, Rank.eq$PartialEq)) as rt.HashMap; + const tuples: rt.HashMap<[rt.u8, string], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashInt, rt.hashStr]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, string], rt.u8>; + let iterStart: rt.usize = 1; + const iterEnd: rt.usize = data.length; + while ((_161 = iterStart++) < iterEnd) { + const i3: rt.usize = _161; + const _169: rt.usize = rt.usizeSub(i3, 1); + rt.idx(data, _169); + const _168: rt.u8 = data[_169]; + rt.idx(data, i3); + const _167: [rt.u8, rt.u8] = [_168, data[i3]]; + const a: rt.u8 = _168; + const b3: rt.u8 = _167[1]; + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map3, { _0: a }, b3), 204)); + const pair: Pair.Pair = { a: rt.u8Rem(a, 4), b: rt.u16Rem(b3 as rt.u16, 3) }; + const t: Tally.Tally = rt.entryOrInsertWith(rt.entry(pairs, pair), Tally.default$Default); + t.n = rt.u16Add(t.n, 1); + const r: Rank.Rank = rank(a, b3); + const _192: Tally.Tally | undefined = rt.hashGet(ranks, r); + if (_192 !== undefined) { + _192.n = rt.u16Add(_192.n, 1); + } else { + rt.hashInsert(ranks, r, { n: i3 & 0xffff }); + } + const _203: rt.u8 = rt.u8Rem(a, 3); + const _207: rt.usize = rt.usizeRem(b3 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + if (!(_207 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _207); + } + const t2: [rt.u8, string] = [_203, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_207]]; + rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashRemove(tuples, t2), 187)); + if (rt.u8Rem(a, 2) === 0) { + rt.hashInsert(tuples, t2, a); + } + } + const _225: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.hashIter(map3), (_214: [Nibble.Nibble, rt.u8]): [rt.u8, rt.u8] => { + return [_214[0]._0, _214[1]] as [rt.u8, rt.u8]; + }); + const iter6: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _225, true)); + while (true) { + const _230: [rt.u8, rt.u8] | rt.Done = iter6.next(); + if (_230 === rt.DONE) { + break; + } + const k3: rt.u8 = _230[0]; + const v2: rt.u8 = _230[1]; + rt.byteVecPush(out, k3); + rt.byteVecPush(out, v2); + } + const key: Pair.Pair = { a: 9, b: 9 }; + const local: Tally.Tally = { n: 7 }; + rt.hashInsert(pairs, key, rt.copy(local)); + local.n = 8; + const before: Tally.Tally = rt.copy(rt.hashIndex(pairs, key)); + const _246: Tally.Tally | undefined = rt.hashGet(pairs, key); + if (_246 !== undefined) { + _246.n = rt.u16Add(_246.n, 2); + } + rt.byteVecPush(out, local.n & 0xff); + rt.byteVecPush(out, before.n & 0xff); + rt.byteVecPush(out, rt.hashIndex(pairs, key).n & 0xff); + const _265: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.hashIter(pairs); + const iter7: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, _265, true)); + while (true) { + const _269: [Pair.Pair, Tally.Tally] | rt.Done = iter7.next(); + if (_269 === rt.DONE) { + break; + } + const p: Pair.Pair = _269[0]; + const t3: Tally.Tally = _269[1]; + rt.byteVecPush(out, p.a); + rt.byteVecPush(out, p.b & 0xff); + rt.byteVecPush(out, t3.n & 0xff); + } + let iterStart2: rt.usize = 1; + const iterEnd2: rt.usize = data.length; + while ((_286 = iterStart2++) < iterEnd2) { + const i4: rt.usize = _286; + const _294: rt.usize = rt.usizeSub(i4, 1); + rt.idx(data, _294); + const _293: rt.u8 = data[_294]; + rt.idx(data, i4); + const _292: [rt.u8, rt.u8] = [_293, data[i4]]; + const a2: rt.u8 = _293; + const b4: rt.u8 = _292[1]; + const _305: Rank.Rank = rank(b4, a2); + const t4: Tally.Tally = rt.entryOrInsertWith(rt.entryAndModify(rt.entry(ranks, _305), (t9: Tally.Tally): void => { + t9.n = t9.n ^ 3; + }), (): Tally.Tally => { + return { n: b4 as rt.u16 }; + }); + t4.n = rt.u16WrappingAdd(t4.n, t4.n); + rt.idx(data, i4); + const _313: Rank.Rank = rank(data[i4], 0); + const e: rt.Entry = rt.entry(ranks, _313); + rt.byteVecPush(out, rankByte(rt.entryKey(e))); + rt.byteVecPush(out, rt.entryOrInsertWith(e, (k9: Rank.Rank): Tally.Tally => { + return { n: rankByte(k9) as rt.u16 }; + }).n & 0xff); + } + const copy: rt.HashMap = rt.hashClone(ranks, undefined, rt.copy); + const _327: Tally.Tally | undefined = rt.hashGet(copy, { tag: "Low" } as Rank.Rank); + if (_327 !== undefined) { + _327.n = 119; + } + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(ranks, { tag: "Low" } as Rank.Rank), 255, (t10: Tally.Tally): rt.u8 => { + return t10.n & 0xff; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(copy, { tag: "Low" } as Rank.Rank), 255, (t11: Tally.Tally): rt.u8 => { + return t11.n & 0xff; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.hashRemoveEntry(copy, { tag: "Mid", _0: 1 } as Rank.Rank), 255, (_218: [Rank.Rank, Tally.Tally]): rt.u8 => { + const k10: Rank.Rank = _218[0]; + const t12: Tally.Tally = _218[1]; + return rankByte(k10) ^ (t12.n & 0xff); + })); + const _348: rt.Iter<[rt.u8, Tally.Tally]> = rt.iterMap(rt.iterSlice(data), (_223: rt.u8): [rt.u8, Tally.Tally] => { + const b8: rt.u8 = _223; + return [rt.u8Rem(b8, 8), { n: b8 as rt.u16 }] as [rt.u8, Tally.Tally]; + }); + const bytes: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _348); + const copy2: rt.HashMap = rt.hashClone(bytes, undefined, rt.copy); + const iter9: rt.Iter = rt.hashValues(copy2); + while (true) { + const _356: Tally.Tally | rt.Done = iter9.next(); + if (_356 === rt.DONE) { + break; + } + _356.n = rt.u16Add(_356.n, 1); + } + let iterStart3: rt.u8 = 0; + const iterEnd3: rt.u8 = 8; + while ((_364 = iterStart3++) < iterEnd3) { + const k4: rt.u8 = _364; + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(bytes, k4), 255, (t13: Tally.Tally): rt.u8 => { + return t13.n & 0xff; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(copy2, k4), 255, (t14: Tally.Tally): rt.u8 => { + return t14.n & 0xff; + })); + } + const iterS: Uint8Array = data; + let iterI: number = 0; + while (true) { + const _380: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_380 === rt.DONE) { + break; + } + const b5: rt.u8 = _380; + const _387: rt.u8 = rt.u8Rem(b5, 8); + const _389: rt.u16 = b5 as rt.u16; + rt.byteVecPush(out, claim(copy2, _387, _389)); + } + const stamped: rt.HashMap = rt.hashNew() as rt.HashMap; + stamp(stamped); + stamp(stamped); + rt.byteVecPush(out, rt.hashLen(stamped) & 0xff); + const extended: rt.HashMap = rt.hashNew() as rt.HashMap; + rt.hashExtend(extended, rt.iterMap(rt.hashIter(bytes), rt.copy)); + const iter12: rt.Iter = rt.hashValues(extended); + while (true) { + const _409: Tally.Tally | rt.Done = iter12.next(); + if (_409 === rt.DONE) { + break; + } + _409.n = _409.n ^ 17; + } + let iterStart4: rt.u8 = 0; + const iterEnd4: rt.u8 = 8; + while ((_416 = iterStart4++) < iterEnd4) { + const k5: rt.u8 = _416; + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(bytes, k5), 255, (t15: Tally.Tally): rt.u8 => { + return t15.n & 0xff; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(extended, k5), 255, (t16: Tally.Tally): rt.u8 => { + return t16.n & 0xff; + })); + } + const first: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + rt.byteVecPush(out, rt.u64Eq(_430({ _0: first }), _430({ _0: first ^ 240 })) ? 1 : 0); + const _448: [rt.Hasher, Tally.Tally] = [rt.hasher(), { n: first as rt.u16 }]; + const h: rt.Hasher = _448[0]; + const counted: Tally.Tally = rt.copy(_448[1]); + const _453: rt.Hasher = countedHasher(h, counted); + const _456: rt.u16 = counted.n; + rt.hashInt(_456, _453); + const want: rt.Hasher = rt.hasher(); + rt.hashInt(rt.u16Add(first as rt.u16, 1), want); + rt.byteVecPush(out, rt.u64Eq(rt.hashFinish(h), rt.hashFinish(want)) ? 1 : 0); + rt.hashRetain(ranks, (r2: Rank.Rank, t17: Tally.Tally): boolean => { + if (!(rt.u16Rem(t17.n, 2) === 0)) { + return Rank.eq$PartialEq(r2, { tag: "Low" } as Rank.Rank); + } + return true; + }); + const _473: rt.Iter<[Rank.Rank, rt.u16]> = rt.iterMap(rt.hashIter(ranks), (_224: [Rank.Rank, Tally.Tally]): [Rank.Rank, rt.u16] => { + return [_224[0], _224[1].n] as [Rank.Rank, rt.u16]; + }); + const iter14: rt.Iter<[Rank.Rank, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap, _473, true)); + while (true) { + const _479: [Rank.Rank, rt.u16] | rt.Done = iter14.next(); + if (_479 === rt.DONE) { + break; + } + rt.byteVecPush(out, rankByte(_479[0])); + rt.byteVecPush(out, _479[1] & 0xff); + } + rt.byteVecPush(out, rt.hashLen(tuples) & 0xff); + } else { const words: rt.HashMap = rt.hashNew() as rt.HashMap; const iterS2: Uint8Array = data; let iterI2: number = 0; while (true) { const _496: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; if (_496 === rt.DONE) { - const lens: rt.BTreeMap = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; - const iter16: rt.Iter<[string, rt.ByteVec]> = rt.hashIter(words); - while (true) { - const _517: [string, rt.ByteVec] | rt.Done = iter16.next(); - if (_517 === rt.DONE) { - const iter17: rt.Iter<[string, rt.usize]> = rt.btreeIter(lens); - while (true) { - const _529: [string, rt.usize] | rt.Done = iter17.next(); - if (_529 === rt.DONE) { - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.hashDrain(words), (_2: [string, rt.ByteVec]): rt.usize => { - return _2[1].length; - }), rt.usizeAdd, 0) & 0xff); - rt.byteVecPush(out, rt.hashLen(words) === 0 ? 1 : 0); - const clashes: rt.HashMap = rt.hashNew(rt.hashing(Clash.hash$Hash_DefaultHasher, Clash.eq$PartialEq)) as rt.HashMap; - const iter18: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); - while (true) { - const _555: [rt.usize, rt.u8] | rt.Done = iter18.next(); - if (_555 === rt.DONE) { - rt.hashRetain(clashes, (k7: Clash.Clash, t8: Tally.Tally): boolean => { - if (!(rt.u8Rem(k7._0, 3) !== 0)) { - return rt.u16Rem(t8.n, 2) === 0; - } - return true; - }); - const _583: rt.Iter = rt.iterMap(rt.hashKeys(clashes), (k8: Clash.Clash): rt.u8 => { - return k8._0; - }); - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _583, true))); - const copy3: rt.HashMap = rt.hashClone(clashes, rt.copy, rt.copy); - rt.byteVecPush(out, rt.hashLen(copy3) & 0xff); - rt.byteVecPush(out, rt.hashContains(copy3, { _0: 1 }) ? 1 : 0); - break b0; - } - const i5: rt.usize = _555[0]; - const b7: rt.u8 = _555[1]; - const k6: Clash.Clash = { _0: rt.u8Rem(b7, 8) }; - const _563: rt.u8 = rt.u8Rem(rt.u8Div(b7, 8), 4); - if (_563 === 0) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashRemove(clashes, k6), 238, (t7: Tally.Tally): rt.u8 => { - return t7.n & 0xff; - })); - } else if (_563 === 1) { - rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(clashes, k6), 221, (t6: Tally.Tally): rt.u8 => { - return t6.n & 0xff; - })); - } else { - rt.byteVecPush(out, rt.optionMapOr(rt.hashInsert(clashes, k6, { n: i5 & 0xffff }), 204, (t5: Tally.Tally): rt.u8 => { - return t5.n & 0xff; - })); - } - } - } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_529[0])); - rt.byteVecPush(out, _529[1] & 0xff); - } - } - const _524: string = _517[0]; - const _525: rt.usize = _517[1].length; - rt.btreeInsert(lens, _524, _525); - } + break; } const b6: rt.u8 = _496; const _502: rt.usize = rt.usizeRem(b6 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); @@ -434,6 +371,68 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { return new rt.ByteVec(); }), b6); } + const lens: rt.BTreeMap = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; + const iter16: rt.Iter<[string, rt.ByteVec]> = rt.hashIter(words); + while (true) { + const _517: [string, rt.ByteVec] | rt.Done = iter16.next(); + if (_517 === rt.DONE) { + break; + } + const _524: string = _517[0]; + const _525: rt.usize = _517[1].length; + rt.btreeInsert(lens, _524, _525); + } + const iter17: rt.Iter<[string, rt.usize]> = rt.btreeIter(lens); + while (true) { + const _529: [string, rt.usize] | rt.Done = iter17.next(); + if (_529 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_529[0])); + rt.byteVecPush(out, _529[1] & 0xff); + } + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.hashDrain(words), (_2: [string, rt.ByteVec]): rt.usize => { + return _2[1].length; + }), rt.usizeAdd, 0) & 0xff); + rt.byteVecPush(out, rt.hashLen(words) === 0 ? 1 : 0); + const clashes: rt.HashMap = rt.hashNew(rt.hashing(Clash.hash$Hash_DefaultHasher, Clash.eq$PartialEq)) as rt.HashMap; + const iter18: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); + while (true) { + const _555: [rt.usize, rt.u8] | rt.Done = iter18.next(); + if (_555 === rt.DONE) { + break; + } + const i5: rt.usize = _555[0]; + const b7: rt.u8 = _555[1]; + const k6: Clash.Clash = { _0: rt.u8Rem(b7, 8) }; + const _563: rt.u8 = rt.u8Rem(rt.u8Div(b7, 8), 4); + if (_563 === 0) { + rt.byteVecPush(out, rt.optionMapOr(rt.hashRemove(clashes, k6), 238, (t7: Tally.Tally): rt.u8 => { + return t7.n & 0xff; + })); + } else if (_563 === 1) { + rt.byteVecPush(out, rt.optionMapOr(rt.hashGet(clashes, k6), 221, (t6: Tally.Tally): rt.u8 => { + return t6.n & 0xff; + })); + } else { + rt.byteVecPush(out, rt.optionMapOr(rt.hashInsert(clashes, k6, { n: i5 & 0xffff }), 204, (t5: Tally.Tally): rt.u8 => { + return t5.n & 0xff; + })); + } + } + rt.hashRetain(clashes, (k7: Clash.Clash, t8: Tally.Tally): boolean => { + if (!(rt.u8Rem(k7._0, 3) !== 0)) { + return rt.u16Rem(t8.n, 2) === 0; + } + return true; + }); + const _583: rt.Iter = rt.iterMap(rt.hashKeys(clashes), (k8: Clash.Clash): rt.u8 => { + return k8._0; + }); + rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _583, true))); + const copy3: rt.HashMap = rt.hashClone(clashes, rt.copy, rt.copy); + rt.byteVecPush(out, rt.hashLen(copy3) & 0xff); + rt.byteVecPush(out, rt.hashContains(copy3, { _0: 1 }) ? 1 : 0); } } @@ -469,131 +468,115 @@ export function claim(map: rt.HashMap, k: rt.u8, n: rt.u16): /** `HashSet` and `BTreeSet`, each with the same script. */ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { - b0: { - const _4: rt.u8 = rt.u8Rem(kind, 3); - if (_4 === 0) { - const hashed: rt.HashSet = rt.hashNew() as rt.HashSet; - const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; - const iterS: Uint8Array = data; - let iterI: number = 0; - while (true) { - const _10: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_10 === rt.DONE) { - rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.hashKeys(hashed), (v2: rt.u16): boolean => { - return rt.u16Rem(v2, 2) === 1; - })) & 0xff); - const iter2: rt.Iter = rt.iterRev(rt.btreeKeys(sorted)); - while (true) { - const _62: rt.u16 | rt.Done = iter2.next(); - if (_62 === rt.DONE) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeFirstKey(sorted), 255) & 0xff); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeFirstKey(sorted, true), 255) & 0xff); - rt.byteVecPush(out, rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12))).length & 0xff); - rt.hashRetain(hashed, (v3: rt.u16): boolean => { - return rt.u16Rem(v3, 3) !== 0; - }); - rt.btreeRetain(sorted, (v4: rt.u16): boolean => { - return rt.u16Rem(v4, 3) !== 0; - }); - rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(sorted), (v5: rt.u16): rt.u8 => { - return v5 & 0xff; - })); - break b0; - } - rt.byteVecPush(out, _62 & 0xff); - } - } - const b: rt.u8 = _10; - const v: rt.u16 = rt.u16Rem(b as rt.u16, 24); - const _17: rt.u8 = rt.u8Rem(b, 3); - if (_17 === 0) { - rt.byteVecPush(out, rt.hashDelete(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeDelete(sorted, v) ? 1 : 0); - } else if (_17 === 1) { - rt.byteVecPush(out, rt.hashContains(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeContains(sorted, v) ? 1 : 0); - } else { - rt.byteVecPush(out, rt.hashAdd(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeAdd(sorted, v) ? 1 : 0); - } + const _4: rt.u8 = rt.u8Rem(kind, 3); + if (_4 === 0) { + const hashed: rt.HashSet = rt.hashNew() as rt.HashSet; + const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; + const iterS: Uint8Array = data; + let iterI: number = 0; + while (true) { + const _10: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_10 === rt.DONE) { + break; + } + const b: rt.u8 = _10; + const v: rt.u16 = rt.u16Rem(b as rt.u16, 24); + const _17: rt.u8 = rt.u8Rem(b, 3); + if (_17 === 0) { + rt.byteVecPush(out, rt.hashDelete(hashed, v) ? 1 : 0); + rt.byteVecPush(out, rt.btreeDelete(sorted, v) ? 1 : 0); + } else if (_17 === 1) { + rt.byteVecPush(out, rt.hashContains(hashed, v) ? 1 : 0); + rt.byteVecPush(out, rt.btreeContains(sorted, v) ? 1 : 0); + } else { + rt.byteVecPush(out, rt.hashAdd(hashed, v) ? 1 : 0); + rt.byteVecPush(out, rt.btreeAdd(sorted, v) ? 1 : 0); + } + } + rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.hashKeys(hashed), (v2: rt.u16): boolean => { + return rt.u16Rem(v2, 2) === 1; + })) & 0xff); + const iter2: rt.Iter = rt.iterRev(rt.btreeKeys(sorted)); + while (true) { + const _62: rt.u16 | rt.Done = iter2.next(); + if (_62 === rt.DONE) { + break; } + rt.byteVecPush(out, _62 & 0xff); } - if (_4 === 1) { - const nibbles: rt.BTreeSet = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet; - const seen: rt.HashSet = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashSet; - const iterS2: Uint8Array = data; - let iterI2: number = 0; - while (true) { - const _106: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_106 === rt.DONE) { - const iter4: rt.Iter = rt.btreeKeys(nibbles); - while (true) { - const _123: Nibble.Nibble | rt.Done = iter4.next(); - if (_123 === rt.DONE) { - while (true) { - const _129: Nibble.Nibble | undefined = rt.btreePopKey(nibbles, true); - if (_129 !== undefined) { - rt.byteVecPush(out, _129._0); - if (rt.usizeRem(rt.btreeLen(nibbles), 2) === 0) { - rt.byteVecPush(out, rt.optionMapOr(rt.btreePopKey(nibbles), 238, (n2: Nibble.Nibble): rt.u8 => { - return n2._0; - })); - } - } else { - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); - const dirs: rt.HashSet = rt.hashNew(rt.hashing(Dir.hash$Hash_DefaultHasher, Dir.eq$PartialEq, true)) as rt.HashSet; - const iterS3: Uint8Array = data; - let iterI3: number = 0; - while (true) { - const _151: rt.u8 | rt.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; - if (_151 === rt.DONE) { - rt.byteVecPush(out, rt.hashLen(dirs) & 0xff); - break b0; - } - const _160: rt.usize = rt.usizeRem(_151 as rt.usize, 3); - if (!(_160 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _160); - } - rt.byteVecPush(out, rt.hashAdd(dirs, ["Up" as Dir.Dir, "Top" as Dir.Dir, "Down" as Dir.Dir][_160]) ? 1 : 0); - } - } - } - } - rt.byteVecPush(out, _123._0); - } + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeFirstKey(sorted), 255) & 0xff); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeFirstKey(sorted, true), 255) & 0xff); + rt.byteVecPush(out, rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12))).length & 0xff); + rt.hashRetain(hashed, (v3: rt.u16): boolean => { + return rt.u16Rem(v3, 3) !== 0; + }); + rt.btreeRetain(sorted, (v4: rt.u16): boolean => { + return rt.u16Rem(v4, 3) !== 0; + }); + rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); + rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(sorted), (v5: rt.u16): rt.u8 => { + return v5 & 0xff; + })); + } else if (_4 === 1) { + const nibbles: rt.BTreeSet = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet; + const seen: rt.HashSet = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashSet; + const iterS2: Uint8Array = data; + let iterI2: number = 0; + while (true) { + const _106: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_106 === rt.DONE) { + break; + } + const b2: rt.u8 = _106; + rt.byteVecPush(out, rt.btreeAdd(nibbles, { _0: b2 }) ? 1 : 0); + rt.byteVecPush(out, rt.hashAdd(seen, { _0: b2 }) ? 1 : 0); + } + const iter4: rt.Iter = rt.btreeKeys(nibbles); + while (true) { + const _123: Nibble.Nibble | rt.Done = iter4.next(); + if (_123 === rt.DONE) { + break; + } + rt.byteVecPush(out, _123._0); + } + while (true) { + const _129: Nibble.Nibble | undefined = rt.btreePopKey(nibbles, true); + if (_129 !== undefined) { + rt.byteVecPush(out, _129._0); + if (rt.usizeRem(rt.btreeLen(nibbles), 2) === 0) { + rt.byteVecPush(out, rt.optionMapOr(rt.btreePopKey(nibbles), 238, (n2: Nibble.Nibble): rt.u8 => { + return n2._0; + })); } - const b2: rt.u8 = _106; - rt.byteVecPush(out, rt.btreeAdd(nibbles, { _0: b2 }) ? 1 : 0); - rt.byteVecPush(out, rt.hashAdd(seen, { _0: b2 }) ? 1 : 0); + } else { + break; + } + } + rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const dirs: rt.HashSet = rt.hashNew(rt.hashing(Dir.hash$Hash_DefaultHasher, Dir.eq$PartialEq, true)) as rt.HashSet; + const iterS3: Uint8Array = data; + let iterI3: number = 0; + while (true) { + const _151: rt.u8 | rt.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; + if (_151 === rt.DONE) { + break; + } + const _160: rt.usize = rt.usizeRem(_151 as rt.usize, 3); + if (!(_160 < 3)) { + rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _160); } + rt.byteVecPush(out, rt.hashAdd(dirs, ["Up" as Dir.Dir, "Top" as Dir.Dir, "Down" as Dir.Dir][_160]) ? 1 : 0); } + rt.byteVecPush(out, rt.hashLen(dirs) & 0xff); + } else { const words: rt.BTreeSet = rt.btreeNew(rt.cmpStr) as rt.BTreeSet; const iterS4: Uint8Array = data; let iterI4: number = 0; while (true) { const _175: rt.u8 | rt.Done = iterI4 < iterS4.length ? iterS4[iterI4++] : rt.DONE; if (_175 === rt.DONE) { - const iter7: rt.Iter = rt.btreeKeys(words); - while (true) { - const _192: string | rt.Done = iter7.next(); - if (_192 === rt.DONE) { - const _200: rt.Iter = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u64 => { - return wide(_2); - }); - const iter8: rt.Iter = rt.iterRev(rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _200, true))); - while (true) { - const _207: rt.u64 | rt.Done = iter8.next(); - if (_207 === rt.DONE) { - break b0; - } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_207)); - } - } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_192)); - rt.byteVecPush(out, 0); - } + break; } const _182: rt.usize = rt.usizeRem(_175 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); if (!(_182 < 8)) { @@ -601,6 +584,26 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } rt.btreeAdd(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_182]); } + const iter7: rt.Iter = rt.btreeKeys(words); + while (true) { + const _192: string | rt.Done = iter7.next(); + if (_192 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_192)); + rt.byteVecPush(out, 0); + } + const _200: rt.Iter = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u64 => { + return wide(_2); + }); + const iter8: rt.Iter = rt.iterRev(rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _200, true))); + while (true) { + const _207: rt.u64 | rt.Done = iter8.next(); + if (_207 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_207)); + } } } @@ -610,189 +613,190 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void let _164!: rt.usize; let _344!: rt.usize; let _401!: rt.u8; - b0: { - const _4: rt.u8 = rt.u8Rem(kind, 4); - if (_4 === 0) { - const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2); - while (true) { - const _13: rt.usize | rt.Done = iter.next(); - if (_13 === rt.DONE) { - rt.byteVecPush(out, rt.optionMapOr(rt.btreeFirst(map), 255, (_223: [rt.u8, rt.u8]): rt.u8 => { - return _223[0]; - })); - rt.byteVecPush(out, rt.optionMapOr(rt.btreeFirst(map, true), 255, (_224: [rt.u8, rt.u8]): rt.u8 => { - return _224[0]; - })); - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.btreeRange(map, new rt.Range(8, 24)); - while (true) { - const _73: [rt.u8, rt.u8] | rt.Done = iter2.next(); - if (_73 === rt.DONE) { - const iter3: rt.Iter<[rt.u8, rt.u8]> = rt.iterRev(rt.btreeRange(map, { start: 10 })); - while (true) { - const _88: [rt.u8, rt.u8] | rt.Done = iter3.next(); - if (_88 === rt.DONE) { - const iter4: rt.Iter = rt.iterMap(rt.btreeRange(map, { end: 6 }), (_229: [rt.u8, rt.u8]): rt.u8 => { - return _229[1]; - }); - while (true) { - const _101: rt.u8 | rt.Done = iter4.next(); - if (_101 === rt.DONE) { - rt.iterExtendBytes(out, rt.btreeKeys(map)); - rt.iterExtendBytes(out, rt.btreeValues(map)); - rt.btreeRemove(map, 3); - rt.byteVecPush(out, rt.btreeLen(map) & 0xff); - rt.byteVecPush(out, rt.btreeContains(map, 3) ? 1 : 0); - const lo: rt.u8 = rt.u8Rem(rt.optionUnwrapOr(rt.sliceFirst(data), 0), 32); - const hi: rt.u8 = rt.u8Rem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0), 32); - const _137: rt.u8 = rt.u8Rem(lo, 3); - if (_137 === 0) { - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.Range(lo, hi)), (_238: [rt.u8, rt.u8]): rt.u8 => { - return _238[0]; - })); - } else if (_137 === 1) { - const _146: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u8Step); - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, _146), (_235: [rt.u8, rt.u8]): rt.u8 => { - return _235[0]; - })); - } else { - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, { start: lo }), (_231: [rt.u8, rt.u8]): rt.u8 => { - return _231[0]; - })); - } - rt.byteVecExtendFromSlice(out, rt.byteVecView(within)); - rt.iterExtendBytes(out, rt.btreeValues(map)); - break b0; - } - rt.byteVecPush(out, _101); - } - } - rt.byteVecPush(out, _88[0] ^ _88[1]); - } - } - rt.byteVecPush(out, _73[0]); - rt.byteVecPush(out, _73[1]); - } - } - const i: rt.usize = _13; - rt.idx(data, i); - const _19: [rt.u8, rt.u8] = [rt.u8Rem(data[i], 32), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0)]; - const k: rt.u8 = _19[0]; - const v: rt.u8 = _19[1]; - const _30: rt.u8 = rt.u8Rem(v, 6); - if (_30 === 0) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeRemove(map, k), 238)); - } else if (_30 === 1) { - rt.byteVecPush(out, rt.optionMapOr(rt.btreePop(map), 221, (_219: [rt.u8, rt.u8]): rt.u8 => { - return _219[0] ^ _219[1]; - })); - } else if (_30 === 2) { - rt.byteVecPush(out, rt.optionMapOr(rt.btreePop(map, true), 220, (_216: [rt.u8, rt.u8]): rt.u8 => { - return _216[0] ^ _216[1]; - })); - } else if (_30 === 3) { - const _42: rt.u8 | undefined = rt.btreeGet(map, k); - if (_42 !== undefined) { - const _50: rt.u8 = rt.u8WrappingAdd(_42, 1); - rt.btreeInsert(map, k, _50); - } - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeGet(map, k), 219)); - } else { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeInsert(map, k, v), 204)); + const _4: rt.u8 = rt.u8Rem(kind, 4); + if (_4 === 0) { + const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; + const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2); + while (true) { + const _13: rt.usize | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break; + } + const i: rt.usize = _13; + rt.idx(data, i); + const _19: [rt.u8, rt.u8] = [rt.u8Rem(data[i], 32), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0)]; + const k: rt.u8 = _19[0]; + const v: rt.u8 = _19[1]; + const _30: rt.u8 = rt.u8Rem(v, 6); + if (_30 === 0) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeRemove(map, k), 238)); + } else if (_30 === 1) { + rt.byteVecPush(out, rt.optionMapOr(rt.btreePop(map), 221, (_219: [rt.u8, rt.u8]): rt.u8 => { + return _219[0] ^ _219[1]; + })); + } else if (_30 === 2) { + rt.byteVecPush(out, rt.optionMapOr(rt.btreePop(map, true), 220, (_216: [rt.u8, rt.u8]): rt.u8 => { + return _216[0] ^ _216[1]; + })); + } else if (_30 === 3) { + const _42: rt.u8 | undefined = rt.btreeGet(map, k); + if (_42 !== undefined) { + const _50: rt.u8 = rt.u8WrappingAdd(_42, 1); + rt.btreeInsert(map, k, _50); } + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeGet(map, k), 219)); + } else { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeInsert(map, k, v), 204)); } } - if (_4 === 1) { - const ranks: rt.BTreeMap = rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap; - const pairs: rt.BTreeMap<[rt.u8, rt.u8], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; - const wides: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; - while (true) { - if (!((_164 = iterStart++) < iterEnd)) { - const _197: Tally.Tally | undefined = rt.btreeGet(ranks, { tag: "Low" } as Rank.Rank); - if (_197 !== undefined) { - _197.n = _197.n ^ 23130; - } - const iterS: Uint8Array = data; - let iterI: number = 0; - while (true) { - const _205: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_205 === rt.DONE) { - const iter7: rt.Iter<[Rank.Rank, Tally.Tally]> = rt.btreeIter(ranks); - while (true) { - const _240: [Rank.Rank, Tally.Tally] | rt.Done = iter7.next(); - if (_240 === rt.DONE) { - const iter8: rt.Iter<[[rt.u8, rt.u8], rt.u8]> = rt.btreeIter(pairs); - while (true) { - const _255: [[rt.u8, rt.u8], rt.u8] | rt.Done = iter8.next(); - if (_255 === rt.DONE) { - const _269: { start: rt.u64 } = { start: 4503599627370496 }; - const iter9: rt.Iter<[rt.u64, rt.u8]> = rt.btreeRange(wides, _269); - while (true) { - const _274: [rt.u64, rt.u8] | rt.Done = iter9.next(); - if (_274 === rt.DONE) { - break b0; - } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_274[0])); - rt.byteVecPush(out, _274[1]); - } - } - rt.byteVecPush(out, rt.u8Shl(_255[0][0], 4) | _255[0][1]); - rt.byteVecPush(out, _255[1]); - } - } - rt.byteVecPush(out, rankByte(_240[0])); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_240[1].n)); - } - } - const b2: rt.u8 = _205; - const r: Rank.Rank = rank(b2, rt.u8Div(b2, 3)); - const _212: rt.Entry = rt.entry(ranks, r); - if (!rt.entryOccupied(_212)) { - const e: rt.Entry = _212; - rt.byteVecPush(out, rankByte(rt.entryKey(e))); - rt.entryOrInsert(e, { n: b2 as rt.u16 }); - } else if (!(rt.entryGet(_212).n > 256)) { - const e3: rt.Entry = _212; - rt.byteVecPush(out, rt.entryInsert(e3, { n: 512 }).n & 0xff); - } else { - const _230: [Rank.Rank, Tally.Tally] = rt.entryRemoveEntry(_212); - rt.byteVecPush(out, rankByte(_230[0])); - } - } - } - const i2: rt.usize = _164; - const _172: rt.usize = rt.usizeSub(i2, 1); - rt.idx(data, _172); - const _171: rt.u8 = data[_172]; - rt.idx(data, i2); - const _170: [rt.u8, rt.u8] = [_171, data[i2]]; - const a: rt.u8 = _171; - const b: rt.u8 = _170[1]; - const _182: Rank.Rank = rank(a, b); - const t: Tally.Tally = rt.entryOrInsertWith(rt.entry(ranks, _182), Tally.default$Default); - t.n = rt.u16WrappingAdd(t.n, b as rt.u16); - const _188: [rt.u8, rt.u8] = [rt.u8Rem(a, 4), rt.u8Rem(b, 4)]; - rt.btreeInsert(pairs, _188, a); - const _196: rt.u64 = wide(a); - rt.entryOrInsertMut(rt.entry(wides, _196), b); - } - } - if (_4 === 2) { - const _287: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.iterMap(rt.iterSlice(data), (_215: rt.u8): [Fussy.Fussy, Fussy.Fussy] => { - const b8: rt.u8 = _215; - return [{ _0: b8 }, { _0: b8 ^ 90 }] as [Fussy.Fussy, Fussy.Fussy]; - }); - const iter10: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.btreeIter(rt.btreeClone(rt.btreeExtend(rt.btreeNew(Fussy.cmp$Ord) as rt.BTreeMap, _287, true), Fussy.clone$Clone, Fussy.clone$Clone)); - while (true) { - const _294: [Fussy.Fussy, Fussy.Fussy] | rt.Done = iter10.next(); - if (_294 === rt.DONE) { - break b0; - } - rt.byteVecPush(out, _294[0]._0 ^ _294[1]._0); + rt.byteVecPush(out, rt.optionMapOr(rt.btreeFirst(map), 255, (_223: [rt.u8, rt.u8]): rt.u8 => { + return _223[0]; + })); + rt.byteVecPush(out, rt.optionMapOr(rt.btreeFirst(map, true), 255, (_224: [rt.u8, rt.u8]): rt.u8 => { + return _224[0]; + })); + const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.btreeRange(map, new rt.Range(8, 24)); + while (true) { + const _73: [rt.u8, rt.u8] | rt.Done = iter2.next(); + if (_73 === rt.DONE) { + break; + } + rt.byteVecPush(out, _73[0]); + rt.byteVecPush(out, _73[1]); + } + const iter3: rt.Iter<[rt.u8, rt.u8]> = rt.iterRev(rt.btreeRange(map, { start: 10 })); + while (true) { + const _88: [rt.u8, rt.u8] | rt.Done = iter3.next(); + if (_88 === rt.DONE) { + break; + } + rt.byteVecPush(out, _88[0] ^ _88[1]); + } + const iter4: rt.Iter = rt.iterMap(rt.btreeRange(map, { end: 6 }), (_229: [rt.u8, rt.u8]): rt.u8 => { + return _229[1]; + }); + while (true) { + const _101: rt.u8 | rt.Done = iter4.next(); + if (_101 === rt.DONE) { + break; + } + rt.byteVecPush(out, _101); + } + rt.iterExtendBytes(out, rt.btreeKeys(map)); + rt.iterExtendBytes(out, rt.btreeValues(map)); + rt.btreeRemove(map, 3); + rt.byteVecPush(out, rt.btreeLen(map) & 0xff); + rt.byteVecPush(out, rt.btreeContains(map, 3) ? 1 : 0); + const lo: rt.u8 = rt.u8Rem(rt.optionUnwrapOr(rt.sliceFirst(data), 0), 32); + const hi: rt.u8 = rt.u8Rem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0), 32); + const _137: rt.u8 = rt.u8Rem(lo, 3); + if (_137 === 0) { + within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.Range(lo, hi)), (_238: [rt.u8, rt.u8]): rt.u8 => { + return _238[0]; + })); + } else if (_137 === 1) { + const _146: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u8Step); + within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, _146), (_235: [rt.u8, rt.u8]): rt.u8 => { + return _235[0]; + })); + } else { + within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, { start: lo }), (_231: [rt.u8, rt.u8]): rt.u8 => { + return _231[0]; + })); + } + rt.byteVecExtendFromSlice(out, rt.byteVecView(within)); + rt.iterExtendBytes(out, rt.btreeValues(map)); + } else if (_4 === 1) { + const ranks: rt.BTreeMap = rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap; + const pairs: rt.BTreeMap<[rt.u8, rt.u8], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; + const wides: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; + let iterStart: rt.usize = 1; + const iterEnd: rt.usize = data.length; + while ((_164 = iterStart++) < iterEnd) { + const i2: rt.usize = _164; + const _172: rt.usize = rt.usizeSub(i2, 1); + rt.idx(data, _172); + const _171: rt.u8 = data[_172]; + rt.idx(data, i2); + const _170: [rt.u8, rt.u8] = [_171, data[i2]]; + const a: rt.u8 = _171; + const b: rt.u8 = _170[1]; + const _182: Rank.Rank = rank(a, b); + const t: Tally.Tally = rt.entryOrInsertWith(rt.entry(ranks, _182), Tally.default$Default); + t.n = rt.u16WrappingAdd(t.n, b as rt.u16); + const _188: [rt.u8, rt.u8] = [rt.u8Rem(a, 4), rt.u8Rem(b, 4)]; + rt.btreeInsert(pairs, _188, a); + const _196: rt.u64 = wide(a); + rt.entryOrInsertMut(rt.entry(wides, _196), b); + } + const _197: Tally.Tally | undefined = rt.btreeGet(ranks, { tag: "Low" } as Rank.Rank); + if (_197 !== undefined) { + _197.n = _197.n ^ 23130; + } + const iterS: Uint8Array = data; + let iterI: number = 0; + while (true) { + const _205: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_205 === rt.DONE) { + break; + } + const b2: rt.u8 = _205; + const r: Rank.Rank = rank(b2, rt.u8Div(b2, 3)); + const _212: rt.Entry = rt.entry(ranks, r); + if (!rt.entryOccupied(_212)) { + const e: rt.Entry = _212; + rt.byteVecPush(out, rankByte(rt.entryKey(e))); + rt.entryOrInsert(e, { n: b2 as rt.u16 }); + } else if (!(rt.entryGet(_212).n > 256)) { + const e3: rt.Entry = _212; + rt.byteVecPush(out, rt.entryInsert(e3, { n: 512 }).n & 0xff); + } else { + const _230: [Rank.Rank, Tally.Tally] = rt.entryRemoveEntry(_212); + rt.byteVecPush(out, rankByte(_230[0])); + } + } + const iter7: rt.Iter<[Rank.Rank, Tally.Tally]> = rt.btreeIter(ranks); + while (true) { + const _240: [Rank.Rank, Tally.Tally] | rt.Done = iter7.next(); + if (_240 === rt.DONE) { + break; + } + rt.byteVecPush(out, rankByte(_240[0])); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_240[1].n)); + } + const iter8: rt.Iter<[[rt.u8, rt.u8], rt.u8]> = rt.btreeIter(pairs); + while (true) { + const _255: [[rt.u8, rt.u8], rt.u8] | rt.Done = iter8.next(); + if (_255 === rt.DONE) { + break; } + rt.byteVecPush(out, rt.u8Shl(_255[0][0], 4) | _255[0][1]); + rt.byteVecPush(out, _255[1]); } + const _269: { start: rt.u64 } = { start: 4503599627370496 }; + const iter9: rt.Iter<[rt.u64, rt.u8]> = rt.btreeRange(wides, _269); + while (true) { + const _274: [rt.u64, rt.u8] | rt.Done = iter9.next(); + if (_274 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_274[0])); + rt.byteVecPush(out, _274[1]); + } + } else if (_4 === 2) { + const _287: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.iterMap(rt.iterSlice(data), (_215: rt.u8): [Fussy.Fussy, Fussy.Fussy] => { + const b8: rt.u8 = _215; + return [{ _0: b8 }, { _0: b8 ^ 90 }] as [Fussy.Fussy, Fussy.Fussy]; + }); + const iter10: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.btreeIter(rt.btreeClone(rt.btreeExtend(rt.btreeNew(Fussy.cmp$Ord) as rt.BTreeMap, _287, true), Fussy.clone$Clone, Fussy.clone$Clone)); + while (true) { + const _294: [Fussy.Fussy, Fussy.Fussy] | rt.Done = iter10.next(); + if (_294 === rt.DONE) { + break; + } + rt.byteVecPush(out, _294[0]._0 ^ _294[1]._0); + } + } else { const nibbles: rt.BTreeMap = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap; const words: rt.BTreeMap = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; const iterS2: Uint8Array = data; @@ -800,85 +804,7 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void while (true) { const _307: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; if (_307 === rt.DONE) { - const iter12: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.btreeIter(nibbles); - while (true) { - const _331: [Nibble.Nibble, rt.u8] | rt.Done = iter12.next(); - if (_331 === rt.DONE) { - let iterStart2: rt.usize = 1; - const iterEnd2: rt.usize = data.length; - while (true) { - if (!((_344 = iterStart2++) < iterEnd2)) { - const _409: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): [Nibble.Nibble, rt.u8] => { - const b5: rt.u8 = _2; - return [{ _0: b5 }, b5] as [Nibble.Nibble, rt.u8]; - }); - const collected: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap, _409, true); - const _412: rt.Iter = rt.iterMap(rt.iterSlice(data), (_213: rt.u8): Nibble.Nibble => { - return { _0: _213 }; - }); - const keys: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet, _412, true); - const _416: rt.Iter = rt.iterMap(rt.iterSlice(data), (_214: rt.u8): Nibble.Nibble => { - return { _0: _214 ^ 48 }; - }); - rt.btreeExtendKeys(keys, _416); - const iter14: rt.Iter<[[Nibble.Nibble, rt.u8], Nibble.Nibble]> = rt.iterZip(rt.btreeIter(collected), rt.btreeKeys(keys)); - while (true) { - const _425: [[Nibble.Nibble, rt.u8], Nibble.Nibble] | rt.Done = iter14.next(); - if (_425 === rt.DONE) { - rt.btreeRetain(words, (w: string, t3: Tally.Tally): boolean => { - if (!(rt.stringLen(w) > 1)) { - return t3.n > 1; - } - return true; - }); - const iter15: rt.Iter<[string, Tally.Tally]> = rt.btreeIter(words); - while (true) { - const _442: [string, Tally.Tally] | rt.Done = iter15.next(); - if (_442 === rt.DONE) { - break b0; - } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_442[0])); - rt.byteVecPush(out, _442[1].n & 0xff); - } - } - rt.byteVecPush(out, _425[0][0]._0); - rt.byteVecPush(out, _425[0][1]); - rt.byteVecPush(out, _425[1]._0); - } - } - const i3: rt.usize = _344; - const _353: rt.usize = rt.usizeSub(i3, 1); - rt.idx(data, _353); - const _351: Nibble.Nibble = { _0: data[_353] }; - rt.idx(data, i3); - const _350: [Nibble.Nibble, Nibble.Nibble] = [_351, { _0: data[i3] }]; - const a2: Nibble.Nibble = _351; - const b4: Nibble.Nibble = _350[1]; - const _365: rt.usize = rt.usizeSub(i3, 1); - rt.idx(data, _365); - const _364: rt.u8 = data[_365]; - rt.idx(data, i3); - const _363: [rt.u8, rt.u8] = [_364, data[i3]]; - const x: rt.u8 = _364; - const y: rt.u8 = _363[1]; - const o: rt.Ordering = rt.orderingThen(rt.orderingReverse(Nibble.cmp$Ord(a2, b4)), (): rt.Ordering => { - return rt.cmp(y, x); - }, true); - rt.byteVecPush(out, (o < 0 ? 1 : 0) | (((o >= 0 ? 1 : 0) << 1) & 0xff) | (((rt.orderingThen(Nibble.cmp$Ord(a2, b4), -1) === 0 ? 1 : 0) << 2) & 0xff)); - if (o === -1) { - _401 = 1; - } else if (o === 0) { - _401 = 2; - } else { - _401 = 3; - } - rt.byteVecPush(out, _401); - rt.byteVecPush(out, o === 1 ? 1 : 0); - } - } - rt.byteVecPush(out, _331[0]._0); - rt.byteVecPush(out, _331[1]); - } + break; } const b3: rt.u8 = _307; rt.byteVecPush(out, rt.optionUnwrapOr(rt.btreeInsert(nibbles, { _0: b3 }, b3), 204)); @@ -889,6 +815,85 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void const t2: Tally.Tally = rt.entryOrInsertWith(rt.entry(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_320]), Tally.default$Default); t2.n = rt.u16Add(t2.n, 1); } + const iter12: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.btreeIter(nibbles); + while (true) { + const _331: [Nibble.Nibble, rt.u8] | rt.Done = iter12.next(); + if (_331 === rt.DONE) { + break; + } + rt.byteVecPush(out, _331[0]._0); + rt.byteVecPush(out, _331[1]); + } + let iterStart2: rt.usize = 1; + const iterEnd2: rt.usize = data.length; + while ((_344 = iterStart2++) < iterEnd2) { + const i3: rt.usize = _344; + const _353: rt.usize = rt.usizeSub(i3, 1); + rt.idx(data, _353); + const _351: Nibble.Nibble = { _0: data[_353] }; + rt.idx(data, i3); + const _350: [Nibble.Nibble, Nibble.Nibble] = [_351, { _0: data[i3] }]; + const a2: Nibble.Nibble = _351; + const b4: Nibble.Nibble = _350[1]; + const _365: rt.usize = rt.usizeSub(i3, 1); + rt.idx(data, _365); + const _364: rt.u8 = data[_365]; + rt.idx(data, i3); + const _363: [rt.u8, rt.u8] = [_364, data[i3]]; + const x: rt.u8 = _364; + const y: rt.u8 = _363[1]; + const o: rt.Ordering = rt.orderingThen(rt.orderingReverse(Nibble.cmp$Ord(a2, b4)), (): rt.Ordering => { + return rt.cmp(y, x); + }, true); + rt.byteVecPush(out, (o < 0 ? 1 : 0) | (((o >= 0 ? 1 : 0) << 1) & 0xff) | (((rt.orderingThen(Nibble.cmp$Ord(a2, b4), -1) === 0 ? 1 : 0) << 2) & 0xff)); + if (o === -1) { + _401 = 1; + } else if (o === 0) { + _401 = 2; + } else { + _401 = 3; + } + rt.byteVecPush(out, _401); + rt.byteVecPush(out, o === 1 ? 1 : 0); + } + const _409: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): [Nibble.Nibble, rt.u8] => { + const b5: rt.u8 = _2; + return [{ _0: b5 }, b5] as [Nibble.Nibble, rt.u8]; + }); + const collected: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap, _409, true); + const _412: rt.Iter = rt.iterMap(rt.iterSlice(data), (_213: rt.u8): Nibble.Nibble => { + return { _0: _213 }; + }); + const keys: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet, _412, true); + const _416: rt.Iter = rt.iterMap(rt.iterSlice(data), (_214: rt.u8): Nibble.Nibble => { + return { _0: _214 ^ 48 }; + }); + rt.btreeExtendKeys(keys, _416); + const iter14: rt.Iter<[[Nibble.Nibble, rt.u8], Nibble.Nibble]> = rt.iterZip(rt.btreeIter(collected), rt.btreeKeys(keys)); + while (true) { + const _425: [[Nibble.Nibble, rt.u8], Nibble.Nibble] | rt.Done = iter14.next(); + if (_425 === rt.DONE) { + break; + } + rt.byteVecPush(out, _425[0][0]._0); + rt.byteVecPush(out, _425[0][1]); + rt.byteVecPush(out, _425[1]._0); + } + rt.btreeRetain(words, (w: string, t3: Tally.Tally): boolean => { + if (!(rt.stringLen(w) > 1)) { + return t3.n > 1; + } + return true; + }); + const iter15: rt.Iter<[string, Tally.Tally]> = rt.btreeIter(words); + while (true) { + const _442: [string, Tally.Tally] | rt.Done = iter15.next(); + if (_442 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_442[0])); + rt.byteVecPush(out, _442[1].n & 0xff); + } } } @@ -908,81 +913,7 @@ export function deques(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _7: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_7 === rt.DONE) { - touch(q); - touch(q); - rt.byteVecPush(out, q.n & 0xff); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); - if (!((q.n === 0))) { - const _71: rt.usize = rt.usizeDiv(q.n, 2); - rt.byteVecPush(out, rt.dequeIndex(q, _71)); - } - rt.dequeRetain(q, (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 2) === 0; - }); - rt.iterExtendBytes(out, rt.dequeIter(q)); - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.dequeIter(pairs); - while (true) { - const _83: [rt.u8, rt.u8] | rt.Done = iter2.next(); - if (_83 === rt.DONE) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.dequeDrain(q, undefined)))); - rt.byteVecPush(out, q.n === 0 ? 1 : 0); - const _101: rt.Iter = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tally.Tally => { - return { n: _2 as rt.u16 }; - }); - const tallies: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _101); - const copy: rt.VecDeque = rt.dequeClone(tallies, rt.copy); - const _105: Tally.Tally | undefined = rt.dequeEnd(copy); - if (_105 !== undefined) { - _105.n = _105.n ^ 255; - } - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t: Tally.Tally): rt.u8 => { - return t.n & 0xff; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t2: Tally.Tally): rt.u8 => { - return t2.n & 0xff; - })); - const _119: rt.Iter = rt.dequeIter(tallies); - rt.dequeExtend(copy, rt.iterMap(_119, rt.copy)); - const _121: Tally.Tally | undefined = rt.dequeEnd(copy, true); - if (_121 !== undefined) { - _121.n = _121.n ^ 255; - } - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t3: Tally.Tally): rt.u8 => { - return t3.n & 0xff; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t4: Tally.Tally): rt.u8 => { - return t4.n & 0xff; - })); - const _135: rt.Iter = rt.iterSlice(data); - rt.dequeExtend(q, _135); - const _139: rt.usize = rt.usizeDiv(q.n, 2); - rt.dequeInsert(q, _139, 66); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeRemove(q, 1), 233)); - rt.dequeTruncate(q, 5); - rt.byteVecPush(out, rt.dequeContains(q, 66, rt.same) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); - const a: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.usize, 8); - const b2: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0) as rt.usize, 8); - const _171: rt.Iter = rt.iterSlice(data); - const q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _171); - const _174: rt.usize = rt.usizeRem(a, 4); - if (_174 === 0) { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2))); - } else if (_174 === 1) { - const _181: rt.RangeInclusive = new rt.RangeInclusive(a, b2, rt.usizeStep); - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, _181)); - } else if (_174 === 2) { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { end: b2 })); - } else { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { start: a })); - } - rt.byteVecExtendFromSlice(out, rt.byteVecView(drained2)); - rt.iterExtendBytes(out, rt.dequeIter(q2)); - rt.byteVecPush(out, rt.dequeIndex(q2, b2)); - return; - } - rt.byteVecPush(out, _83[0] ^ _83[1]); - } + break; } const b: rt.u8 = _7; const _12: rt.u8 = rt.u8Rem(b, 7); @@ -1006,6 +937,81 @@ export function deques(data: Uint8Array, out: rt.ByteVec): void { rt.dequePopFront(pairs); } } + touch(q); + touch(q); + rt.byteVecPush(out, q.n & 0xff); + rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); + if (!((q.n === 0))) { + const _71: rt.usize = rt.usizeDiv(q.n, 2); + rt.byteVecPush(out, rt.dequeIndex(q, _71)); + } + rt.dequeRetain(q, (b3: rt.u8): boolean => { + return rt.u8Rem(b3, 2) === 0; + }); + rt.iterExtendBytes(out, rt.dequeIter(q)); + const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.dequeIter(pairs); + while (true) { + const _83: [rt.u8, rt.u8] | rt.Done = iter2.next(); + if (_83 === rt.DONE) { + break; + } + rt.byteVecPush(out, _83[0] ^ _83[1]); + } + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.dequeDrain(q, undefined)))); + rt.byteVecPush(out, q.n === 0 ? 1 : 0); + const _101: rt.Iter = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tally.Tally => { + return { n: _2 as rt.u16 }; + }); + const tallies: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _101); + const copy: rt.VecDeque = rt.dequeClone(tallies, rt.copy); + const _105: Tally.Tally | undefined = rt.dequeEnd(copy); + if (_105 !== undefined) { + _105.n = _105.n ^ 255; + } + rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t: Tally.Tally): rt.u8 => { + return t.n & 0xff; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t2: Tally.Tally): rt.u8 => { + return t2.n & 0xff; + })); + const _119: rt.Iter = rt.dequeIter(tallies); + rt.dequeExtend(copy, rt.iterMap(_119, rt.copy)); + const _121: Tally.Tally | undefined = rt.dequeEnd(copy, true); + if (_121 !== undefined) { + _121.n = _121.n ^ 255; + } + rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t3: Tally.Tally): rt.u8 => { + return t3.n & 0xff; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t4: Tally.Tally): rt.u8 => { + return t4.n & 0xff; + })); + const _135: rt.Iter = rt.iterSlice(data); + rt.dequeExtend(q, _135); + const _139: rt.usize = rt.usizeDiv(q.n, 2); + rt.dequeInsert(q, _139, 66); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.dequeRemove(q, 1), 233)); + rt.dequeTruncate(q, 5); + rt.byteVecPush(out, rt.dequeContains(q, 66, rt.same) ? 1 : 0); + rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); + const a: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.usize, 8); + const b2: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0) as rt.usize, 8); + const _171: rt.Iter = rt.iterSlice(data); + const q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _171); + const _174: rt.usize = rt.usizeRem(a, 4); + if (_174 === 0) { + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2))); + } else if (_174 === 1) { + const _181: rt.RangeInclusive = new rt.RangeInclusive(a, b2, rt.usizeStep); + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, _181)); + } else if (_174 === 2) { + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { end: b2 })); + } else { + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { start: a })); + } + rt.byteVecExtendFromSlice(out, rt.byteVecView(drained2)); + rt.iterExtendBytes(out, rt.dequeIter(q2)); + rt.byteVecPush(out, rt.dequeIndex(q2, b2)); } //# sourceMappingURL=collections.ts.map diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index ee0ca36bc..79a9f4cd9 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -133,47 +133,7 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _9: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_9 === rt.DONE) { - const _36: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(data)); - if (_36.ok) { - const arg5 = _36.value; - const _48: rt.Fmt = (f: rt.Formatter) => rt.fmtStr(arg5, f); - const arg6 = _36.value; - const args4: rt.Fmt[] = [_48, (f: rt.Formatter) => rt.fmtPad(f, arg6)]; - put(out, rt.fmtFormat([args4[0], " ", rt.fmtSpec({ align: ">", width: 4 }, args4[1])])); - } else { - const arg3 = _36.error; - const _61: rt.Fmt = (f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(arg3, f); - const arg4 = _36.error; - const args6: rt.Fmt[] = [_61, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(arg4, f)]; - put(out, rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ alternate: true }, args6[1]), " ", rt.fmtSpec({ align: ">", width: 80 }, args6[0])])); - } - const _66: rt.u8 | undefined = rt.sliceFirst(data); - b2: { - if (_66 !== undefined) { - if (rt.u8Rem(_66, 2) === 0) { - flag = true; - break b2; - } - } - flag = false; - } - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f)]; - put(out, rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ align: ">", width: 6 }, args8[0]), " ", args8[2], " ", rt.fmtSpec({ alternate: true }, args8[3])])); - const _94: boolean = flag; - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtBool(_94, f))); - const _95: rt.Result = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); - if (_95.ok) { - const arg9 = ([_95.value] as [rt.u8])[0]; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg9, f)]; - put(out, rt.fmtFormat([args10[0]])); - } else { - const arg7 = _95.error; - const _122: rt.Fmt = (f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(arg7, f); - const arg8 = _95.error; - const args12: rt.Fmt[] = [_122, (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(arg8, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ align: ">", width: 40 }, args12[0]), "|"])); - } - return; + break; } const _15: rt.usize = rt.usizeRem(_9 as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length); if (!(_15 < 14)) { @@ -186,6 +146,46 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { const args2: rt.Fmt[] = [_31, (f: rt.Formatter) => rt.fmtStr(arg2, f)]; put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ width: 8 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ width: 12 }, args2[1]), "|", rt.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"])); } + const _36: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(data)); + if (_36.ok) { + const arg5 = _36.value; + const _48: rt.Fmt = (f: rt.Formatter) => rt.fmtStr(arg5, f); + const arg6 = _36.value; + const args4: rt.Fmt[] = [_48, (f: rt.Formatter) => rt.fmtPad(f, arg6)]; + put(out, rt.fmtFormat([args4[0], " ", rt.fmtSpec({ align: ">", width: 4 }, args4[1])])); + } else { + const arg3 = _36.error; + const _61: rt.Fmt = (f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(arg3, f); + const arg4 = _36.error; + const args6: rt.Fmt[] = [_61, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(arg4, f)]; + put(out, rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ alternate: true }, args6[1]), " ", rt.fmtSpec({ align: ">", width: 80 }, args6[0])])); + } + const _66: rt.u8 | undefined = rt.sliceFirst(data); + b3: { + if (_66 !== undefined) { + if (rt.u8Rem(_66, 2) === 0) { + flag = true; + break b3; + } + } + flag = false; + } + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f)]; + put(out, rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ align: ">", width: 6 }, args8[0]), " ", args8[2], " ", rt.fmtSpec({ alternate: true }, args8[3])])); + const _94: boolean = flag; + put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtBool(_94, f))); + const _95: rt.Result = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); + if (_95.ok) { + const arg9 = ([_95.value] as [rt.u8])[0]; + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg9, f)]; + put(out, rt.fmtFormat([args10[0]])); + } else { + const arg7 = _95.error; + const _122: rt.Fmt = (f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(arg7, f); + const arg8 = _95.error; + const args12: rt.Fmt[] = [_122, (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(arg8, f)]; + put(out, rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ align: ">", width: 40 }, args12[0]), "|"])); + } } export function nested(data: Uint8Array): Nested.Nested { diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 5f43d28f9..8d75c4e92 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -48,25 +48,7 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _140: Either.Either | rt.Done = iter.next(); if (_140 === rt.DONE) { - const list: Wrap.Wrap = new Wrap.Wrap({ value: [], count: 1 }); - const _171: rt.u16 = at(10) as rt.u16; - list.value.push(_171); - Wrap.bump$Vec_u16(list); - const none: Wrap.Wrap = new Wrap.Wrap({ value: undefined, count: 0 }); - const some: Wrap.Wrap = Wrap.new$Option_u8(rt.sliceGet(data, 11)); - const err: Wrap.Wrap> = new Wrap.Wrap({ value: rt.Err({ tag: "Dot" } as Shape.Shape), count: 2 }); - const _193: rt.u8 = rt.optionUnwrapOr(Wrap.get$Option_u8(none), some.count); - const args10: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), (f: rt.Formatter) => rt.u8Display(_193, f)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]])); - const tagged: Tagged.Tagged, rt.i16> = new Tagged.Tagged({ key: { tag: "Right", value: 500 } as Either.Either, inner: Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), all: rt.sliceToVec([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)]) }); - [Tagged.first$Either_u8_u16_i16(tagged), tagged] as [Wrap.Wrap | undefined, Tagged.Tagged, rt.i16>]; - const _241: rt.Fmt = (f: rt.Formatter) => Tagged.fmt$Debug_Either_u8_u16_i16(tagged, f); - const arg5 = Tagged.first$Either_u8_u16_i16(tagged); - const args12: rt.Fmt[] = [_241, (f: rt.Formatter) => rt.fmtOption(arg5, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))]; - put(out, rt.fmtFormat([args12[0], " ", args12[1]])); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(tagged.inner.value)); - rt.byteVecPush(out, rt.optionUnwrapOr(Either.left$u8_u16(tagged.key), 0)); - return; + break; } const either: Either.Either = _140; const flipped: Either.Either = Either.flip$u8_Point(either); @@ -79,6 +61,24 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { const args8: rt.Fmt[] = [_161, _162, _163, (f: rt.Formatter) => rt.fmtOption(arg4, f, (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f))]; put(out, rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[1]), " ", args8[2], " ", args8[3]])); } + const list: Wrap.Wrap = new Wrap.Wrap({ value: [], count: 1 }); + const _171: rt.u16 = at(10) as rt.u16; + list.value.push(_171); + Wrap.bump$Vec_u16(list); + const none: Wrap.Wrap = new Wrap.Wrap({ value: undefined, count: 0 }); + const some: Wrap.Wrap = Wrap.new$Option_u8(rt.sliceGet(data, 11)); + const err: Wrap.Wrap> = new Wrap.Wrap({ value: rt.Err({ tag: "Dot" } as Shape.Shape), count: 2 }); + const _193: rt.u8 = rt.optionUnwrapOr(Wrap.get$Option_u8(none), some.count); + const args10: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), (f: rt.Formatter) => rt.u8Display(_193, f)]; + put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]])); + const tagged: Tagged.Tagged, rt.i16> = new Tagged.Tagged({ key: { tag: "Right", value: 500 } as Either.Either, inner: Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), all: rt.sliceToVec([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)]) }); + [Tagged.first$Either_u8_u16_i16(tagged), tagged] as [Wrap.Wrap | undefined, Tagged.Tagged, rt.i16>]; + const _241: rt.Fmt = (f: rt.Formatter) => Tagged.fmt$Debug_Either_u8_u16_i16(tagged, f); + const arg5 = Tagged.first$Either_u8_u16_i16(tagged); + const args12: rt.Fmt[] = [_241, (f: rt.Formatter) => rt.fmtOption(arg5, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))]; + put(out, rt.fmtFormat([args12[0], " ", args12[1]])); + rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(tagged.inner.value)); + rt.byteVecPush(out, rt.optionUnwrapOr(Either.left$u8_u16(tagged.key), 0)); } //# sourceMappingURL=generics.ts.map diff --git a/ts/fixtures/lang/expected/iters.Evens.ts b/ts/fixtures/lang/expected/iters.Evens.ts index 4ea3ae9e3..7644fb781 100644 --- a/ts/fixtures/lang/expected/iters.Evens.ts +++ b/ts/fixtures/lang/expected/iters.Evens.ts @@ -8,17 +8,18 @@ export interface Evens { } export function next$Iterator(self: Evens): rt.u8 | rt.Done { - l0: while (true) { + while (true) { const _2: rt.u8 | rt.Done = self.inner.next(); if (_2 !== rt.DONE) { const b: rt.u8 = _2; - if (!(rt.u8Rem(b, 2) === 0)) { - continue l0; + if (rt.u8Rem(b, 2) === 0) { + return b; } - return b; + } else { + break; } - return rt.DONE; } + return rt.DONE; } //# sourceMappingURL=iters.Evens.ts.map diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index fda298c02..6fe0d81a7 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -29,124 +29,123 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { while (true) { const _18: rt.u16 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_18 === rt.DONE) { - break b0; + break; } rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_18)); } - } - if (_4 === 1) { - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(data)), 1), 2); - while (true) { - const _32: [rt.usize, rt.u8] | rt.Done = iter2.next(); - if (_32 === rt.DONE) { - const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(data))), 3); - while (true) { - const _46: [rt.usize, rt.u8] | rt.Done = iter3.next(); - if (_46 === rt.DONE) { - break b0; - } - rt.byteVecPush(out, (_46[0] & 0xff) ^ _46[1]); + } else { + if (_4 === 1) { + const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(data)), 1), 2); + while (true) { + const _32: [rt.usize, rt.u8] | rt.Done = iter2.next(); + if (_32 === rt.DONE) { + break; } + const i: rt.usize = _32[0]; + const b: rt.u8 = _32[1]; + rt.byteVecPush(out, i & 0xff); + rt.byteVecPush(out, b); + } + const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(data))), 3); + while (true) { + const _46: [rt.usize, rt.u8] | rt.Done = iter3.next(); + if (_46 === rt.DONE) { + break b0; + } + rt.byteVecPush(out, (_46[0] & 0xff) ^ _46[1]); } - const i: rt.usize = _32[0]; - const b: rt.u8 = _32[1]; - rt.byteVecPush(out, i & 0xff); - rt.byteVecPush(out, b); } - } - if (_4 === 2) { - const _56: [Uint8Array, Uint8Array] = rt.sliceSplitAt(data, rt.usizeDiv(data.length, 2)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(_56[0]), rt.iterRev(rt.iterSlice(_56[1]))), (_215: [rt.u8, rt.u8]): rt.u8 => { - return _215[0] ^ _215[1]; - })))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(_56[0]), rt.iterSlice(_56[1])))))); - } else if (_4 === 3) { - const taken: rt.ByteVec = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(data), (_212: rt.u8): boolean => { - return _212 !== 0; - })); - const skipped: rt.ByteVec = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(data), (_213: rt.u8): boolean => { - return _213 < 128; - })); - const mapped: rt.ByteVec = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(data), (_214: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedAdd(_214, 64); - })); - rt.byteVecPush(out, taken.length & 0xff); - rt.byteVecPush(out, skipped.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecView(mapped)); - } else if (_4 === 4) { - const words: rt.ByteVec[] = chunksByZero$ChunksByZero_u8s(data); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { - return rt.iterRev(rt.iterSlice(rt.byteVecView(w))); - })))); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { - return rt.iterMap(rt.iterSlice(rt.byteVecView(w2)), (_211: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(_211, 3); - }); - })))); - } else { - if (_4 === 5) { - const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(data)); - l4: while (true) { - const _118: rt.u8 | rt.Done = it.next(); - if (_118 !== rt.DONE) { - const b2: rt.u8 = _118; - let run: rt.u8 = 1; - while (true) { - if (!((rt.peekableNextIf(it, (_210: rt.u8): boolean => { + if (_4 === 2) { + const _56: [Uint8Array, Uint8Array] = rt.sliceSplitAt(data, rt.usizeDiv(data.length, 2)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(_56[0]), rt.iterRev(rt.iterSlice(_56[1]))), (_215: [rt.u8, rt.u8]): rt.u8 => { + return _215[0] ^ _215[1]; + })))); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(_56[0]), rt.iterSlice(_56[1])))))); + } else if (_4 === 3) { + const taken: rt.ByteVec = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(data), (_212: rt.u8): boolean => { + return _212 !== 0; + })); + const skipped: rt.ByteVec = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(data), (_213: rt.u8): boolean => { + return _213 < 128; + })); + const mapped: rt.ByteVec = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(data), (_214: rt.u8): rt.u8 | undefined => { + return rt.u8CheckedAdd(_214, 64); + })); + rt.byteVecPush(out, taken.length & 0xff); + rt.byteVecPush(out, skipped.length & 0xff); + rt.byteVecExtendFromSlice(out, rt.byteVecView(mapped)); + } else if (_4 === 4) { + const words: rt.ByteVec[] = chunksByZero$ChunksByZero_u8s(data); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { + return rt.iterRev(rt.iterSlice(rt.byteVecView(w))); + })))); + rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { + return rt.iterMap(rt.iterSlice(rt.byteVecView(w2)), (_211: rt.u8): rt.u8 => { + return rt.u8WrappingAdd(_211, 3); + }); + })))); + } else { + if (_4 === 5) { + const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(data)); + while (true) { + const _118: rt.u8 | rt.Done = it.next(); + if (_118 !== rt.DONE) { + const b2: rt.u8 = _118; + let run: rt.u8 = 1; + while (rt.peekableNextIf(it, (_210: rt.u8): boolean => { return _210 === b2; - }) !== undefined))) { - rt.byteVecPush(out, b2); - rt.byteVecPush(out, run); - const _133: rt.u8 | undefined = rt.peekablePeek(it); - if (_133 !== undefined) { - rt.byteVecPush(out, _133); - continue l4; - } - continue l4; + }) !== undefined) { + run = rt.u8Add(run, 1); + } + rt.byteVecPush(out, b2); + rt.byteVecPush(out, run); + const _133: rt.u8 | undefined = rt.peekablePeek(it); + if (_133 !== undefined) { + rt.byteVecPush(out, _133); } - run = rt.u8Add(run, 1); + } else { + break b0; } } - break b0; } - } - if (_4 === 6) { - const it2: rt.Iter = rt.iterSlice(data); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterTake(it2, 2)))); - rt.byteVecPush(out, it2.len() & 0xff); - const _152: rt.u8 | undefined = rt.iterToOption(it2.nextBack()); - if (_152 === undefined) { - rt.byteVecPush(out, 238); + if (_4 === 6) { + const it2: rt.Iter = rt.iterSlice(data); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterTake(it2, 2)))); + rt.byteVecPush(out, it2.len() & 0xff); + const _152: rt.u8 | undefined = rt.iterToOption(it2.nextBack()); + if (_152 === undefined) { + rt.byteVecPush(out, 238); + } else { + rt.byteVecPush(out, _152); + } + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)))); } else { - rt.byteVecPush(out, _152); - } - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)))); - } else { - const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Uint8Array => { - const b3: rt.u8 = _2; - return Uint8Array.of(b3, ~b3 & 0xff); - })); - const copies: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs), rt.copy)); - if (!((copies.length === 0))) { - const at = rt.idx(copies, 0); - copies[at][0] = 85; - } - const iter4: rt.Iter = rt.iterChain(rt.iterSlice(pairs), rt.iterSlice(copies)); - while (true) { - const _187: Uint8Array | rt.Done = iter4.next(); - if (_187 === rt.DONE) { - const v2: rt.u16[] = []; - const _196: rt.Iter = rt.iterMap(rt.iterSlice(data), (_22: rt.u8): rt.u16 => { - return rt.u16Add(_22 as rt.u16, 1); - }); - rt.iterExtend(v2, _196); - rt.byteVecPush(out, v2.length & 0xff); - rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(data), (_24: rt.u8): boolean => { - return _24 > 128; - })); - break b0; + const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Uint8Array => { + const b3: rt.u8 = _2; + return Uint8Array.of(b3, ~b3 & 0xff); + })); + const copies: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs), rt.copy)); + if (!((copies.length === 0))) { + const at = rt.idx(copies, 0); + copies[at][0] = 85; } - rt.byteVecExtendFromSlice(out, _187); + const iter4: rt.Iter = rt.iterChain(rt.iterSlice(pairs), rt.iterSlice(copies)); + while (true) { + const _187: Uint8Array | rt.Done = iter4.next(); + if (_187 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, _187); + } + const v2: rt.u16[] = []; + const _196: rt.Iter = rt.iterMap(rt.iterSlice(data), (_22: rt.u8): rt.u16 => { + return rt.u16Add(_22 as rt.u16, 1); + }); + rt.iterExtend(v2, _196); + rt.byteVecPush(out, v2.length & 0xff); + rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(data), (_24: rt.u8): boolean => { + return _24 > 128; + })); } } } @@ -162,8 +161,7 @@ export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { while (true) { const _6: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_6 === rt.DONE) { - words.push(word); - return words; + break; } const b: rt.u8 = _6; if (!(b === 0)) { @@ -175,150 +173,148 @@ export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { words.push(_13); } } + words.push(word); + return words; } /** Consumers, and how far each reads: `log` records every item a closure sees. */ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const log: rt.ByteVec = new rt.ByteVec(); - b0: { - const _5: rt.u8 = rt.u8Rem(kind, 6); - if (_5 === 0) { - const _9: rt.Iter = rt.iterInspect(rt.iterSlice(data), (_228: rt.u8): void => { - rt.byteVecPush(log, _228); - }); - rt.byteVecPush(out, rt.iterAny(_9, (_229: rt.u8): boolean => { - return _229 > 240; - }) ? 1 : 0); - const _17: rt.Iter = rt.iterSlice(data); - rt.byteVecPush(out, rt.iterAll(_17, (_230: rt.u8): boolean => { - return _230 !== 0; - }) ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.iterSlice(data)) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(data), (_231: rt.u8): boolean => { - return rt.u8Rem(_231, 2) === 0; - })) & 0xff); - } else { - if (_5 === 1) { - const _31: rt.Iter = rt.iterInspect(rt.iterSlice(data), (_220: rt.u8): void => { - rt.byteVecPush(log, _220); - }); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFind(_31, (_221: rt.u8): boolean => { - return rt.u8Rem(_221, 7) === 3; - }), 255)); - const _40: rt.Iter = rt.iterSlice(data); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFindMap(_40, (_222: rt.u8): rt.u8 | undefined => { - const b14: rt.u8 = _222; - if (!(b14 > 80)) { - return undefined; - } - return rt.u8CheckedMul(b14, 3); - }), 0)); - const _45: rt.Iter = rt.iterSlice(data); - rt.byteVecPush(out, rt.optionMapOr(rt.iterPosition(_45, (_223: rt.u8): boolean => { - return _223 === 64; - }), 255, (p: rt.usize): rt.u8 => { - return p & 0xff; - })); - const short: Uint8Array = rt.sliceRange(data, rt.usizeDiv(data.length, 2)); - rt.byteVecPush(out, rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(data), (_224: rt.u8): rt.u8 => { - const b16: rt.u8 = _224; - rt.byteVecPush(log, b16); - return b16; - }), rt.iterSlice(short), true)) & 0xff); - const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_225: rt.u8): rt.u8 => { - const b17: rt.u8 = _225; - rt.byteVecPush(log, ~b17 & 0xff); - return b17; - }), rt.iterSlice(short), true); - while (true) { - const _69: [rt.u8, rt.u8] | rt.Done = iter.next(); - if (_69 === rt.DONE) { - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_226: rt.u8): void => { - rt.byteVecPush(log, _226); - }), (b19: rt.u8): rt.u8 => { - return b19; - }), rt.iterSlice(short)); - while (true) { - const _85: [rt.u8, rt.u8] | rt.Done = iter2.next(); - if (_85 === rt.DONE) { - const back: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_227: rt.u8): rt.u8 => { - return rotateFree$RotateFree_u8(_227); - }), rt.iterSlice(short), true); - const _97: [rt.u8, rt.u8] | undefined = rt.iterToOption(back.nextBack()); - if (_97 !== undefined) { - const a3: rt.u8 = _97[0]; - const b2: rt.u8 = _97[1]; - rt.byteVecPush(out, a3); - rt.byteVecPush(out, b2); - } - rt.byteVecPush(out, back.len() & 0xff); - break b0; - } - rt.byteVecPush(out, _85[0] ^ _85[1]); - } - } - rt.byteVecPush(out, _69[0] ^ _69[1]); - } + const _5: rt.u8 = rt.u8Rem(kind, 6); + if (_5 === 0) { + const _9: rt.Iter = rt.iterInspect(rt.iterSlice(data), (_228: rt.u8): void => { + rt.byteVecPush(log, _228); + }); + rt.byteVecPush(out, rt.iterAny(_9, (_229: rt.u8): boolean => { + return _229 > 240; + }) ? 1 : 0); + const _17: rt.Iter = rt.iterSlice(data); + rt.byteVecPush(out, rt.iterAll(_17, (_230: rt.u8): boolean => { + return _230 !== 0; + }) ? 1 : 0); + rt.byteVecPush(out, rt.iterCount(rt.iterSlice(data)) & 0xff); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(data), (_231: rt.u8): boolean => { + return rt.u8Rem(_231, 2) === 0; + })) & 0xff); + } else if (_5 === 1) { + const _31: rt.Iter = rt.iterInspect(rt.iterSlice(data), (_220: rt.u8): void => { + rt.byteVecPush(log, _220); + }); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFind(_31, (_221: rt.u8): boolean => { + return rt.u8Rem(_221, 7) === 3; + }), 255)); + const _40: rt.Iter = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFindMap(_40, (_222: rt.u8): rt.u8 | undefined => { + const b14: rt.u8 = _222; + if (!(b14 > 80)) { + return undefined; } - if (_5 === 2) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMax(rt.iterSlice(data)), 0)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMin(rt.iterSlice(data)), 255)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterSlice(data), (_218: rt.u8): rt.u8 => { - return rt.u8Rem(_218, 16); - }), 238)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMinByKey(rt.iterSlice(data), (_219: rt.u8): rt.u8 => { - return rt.u8Div(_219, 16); - }), 238)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterLast(rt.iterSlice(data)), 221)); - const _140: rt.Iter = rt.iterSlice(data); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_140, 3), 204)); - const it: rt.Iter = rt.iterSlice(data); - const _147: rt.Iter = rt.iterTake(it, rt.usizeRem(data.length, 3)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(_147.nthBackItem(1)), 187)); - rt.byteVecPush(out, it.len() & 0xff); - const _162: rt.Iter = rt.iterTake(it, rt.usizeRem(data.length, 5)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_162, 2), 187)); - rt.byteVecPush(out, it.len() & 0xff); - } else if (_5 === 3) { - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(data), (_214: rt.u8): rt.u64 => { - return rt.u64Mul(_214 as rt.u64, 1103823438081); - }), rt.u64Add, 0))); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { - const b8: rt.u8 = _34; - const _510: rt.u32 = (acc << 3) >>> 0; - return rt.u32WrappingAdd(_510, (b8 as rt.u32 ^ acc) >>> 0); - }))); - rt.iterForEach(rt.iterSlice(data), (_216: rt.u8): void => { - rt.byteVecPush(log, rotateFree$RotateFree_u8(_216)); - }); - } else if (_5 === 4) { - rt.byteVecPush(out, rt.iterSum(rt.iterSlice(data), rt.u8Add, 0)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(data), (_213: rt.u8): rt.u16 => { - return rt.u16Add(rt.u16Rem(_213 as rt.u16, 4), 1); - }), rt.u16Mul, 1))); - } else { - const parsed: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.Result => { - const b3: rt.u8 = _2; - if (!(b3 < 240)) { - return rt.Err(b3); - } - return rt.Ok(b3); - }), (values__: rt.Iter) => rt.iterToByteVec(values__)); - if (parsed.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(parsed.value)); - } else { - rt.byteVecPush(out, parsed.error); - } - rt.byteVecPush(out, rt.optionMapOr(rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_24: rt.u8): void => { - rt.byteVecPush(log, _24); - }), (_29: rt.u8): rt.u16 | undefined => { - const b5: rt.u8 = _29; - return rt.thenSome(b5 !== 32, b5 as rt.u16); - }), (values__: rt.Iter) => rt.iterToArray(values__)), 255, (v2: rt.u16[]): rt.u8 => { - return v2.length & 0xff; - })); + return rt.u8CheckedMul(b14, 3); + }), 0)); + const _45: rt.Iter = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionMapOr(rt.iterPosition(_45, (_223: rt.u8): boolean => { + return _223 === 64; + }), 255, (p: rt.usize): rt.u8 => { + return p & 0xff; + })); + const short: Uint8Array = rt.sliceRange(data, rt.usizeDiv(data.length, 2)); + rt.byteVecPush(out, rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(data), (_224: rt.u8): rt.u8 => { + const b16: rt.u8 = _224; + rt.byteVecPush(log, b16); + return b16; + }), rt.iterSlice(short), true)) & 0xff); + const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_225: rt.u8): rt.u8 => { + const b17: rt.u8 = _225; + rt.byteVecPush(log, ~b17 & 0xff); + return b17; + }), rt.iterSlice(short), true); + while (true) { + const _69: [rt.u8, rt.u8] | rt.Done = iter.next(); + if (_69 === rt.DONE) { + break; + } + rt.byteVecPush(out, _69[0] ^ _69[1]); + } + const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_226: rt.u8): void => { + rt.byteVecPush(log, _226); + }), (b19: rt.u8): rt.u8 => { + return b19; + }), rt.iterSlice(short)); + while (true) { + const _85: [rt.u8, rt.u8] | rt.Done = iter2.next(); + if (_85 === rt.DONE) { + break; + } + rt.byteVecPush(out, _85[0] ^ _85[1]); + } + const back: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_227: rt.u8): rt.u8 => { + return rotateFree$RotateFree_u8(_227); + }), rt.iterSlice(short), true); + const _97: [rt.u8, rt.u8] | undefined = rt.iterToOption(back.nextBack()); + if (_97 !== undefined) { + const a3: rt.u8 = _97[0]; + const b2: rt.u8 = _97[1]; + rt.byteVecPush(out, a3); + rt.byteVecPush(out, b2); + } + rt.byteVecPush(out, back.len() & 0xff); + } else if (_5 === 2) { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMax(rt.iterSlice(data)), 0)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMin(rt.iterSlice(data)), 255)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterSlice(data), (_218: rt.u8): rt.u8 => { + return rt.u8Rem(_218, 16); + }), 238)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMinByKey(rt.iterSlice(data), (_219: rt.u8): rt.u8 => { + return rt.u8Div(_219, 16); + }), 238)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterLast(rt.iterSlice(data)), 221)); + const _140: rt.Iter = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_140, 3), 204)); + const it: rt.Iter = rt.iterSlice(data); + const _147: rt.Iter = rt.iterTake(it, rt.usizeRem(data.length, 3)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(_147.nthBackItem(1)), 187)); + rt.byteVecPush(out, it.len() & 0xff); + const _162: rt.Iter = rt.iterTake(it, rt.usizeRem(data.length, 5)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_162, 2), 187)); + rt.byteVecPush(out, it.len() & 0xff); + } else if (_5 === 3) { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(data), (_214: rt.u8): rt.u64 => { + return rt.u64Mul(_214 as rt.u64, 1103823438081); + }), rt.u64Add, 0))); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { + const b8: rt.u8 = _34; + const _510: rt.u32 = (acc << 3) >>> 0; + return rt.u32WrappingAdd(_510, (b8 as rt.u32 ^ acc) >>> 0); + }))); + rt.iterForEach(rt.iterSlice(data), (_216: rt.u8): void => { + rt.byteVecPush(log, rotateFree$RotateFree_u8(_216)); + }); + } else if (_5 === 4) { + rt.byteVecPush(out, rt.iterSum(rt.iterSlice(data), rt.u8Add, 0)); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(data), (_213: rt.u8): rt.u16 => { + return rt.u16Add(rt.u16Rem(_213 as rt.u16, 4), 1); + }), rt.u16Mul, 1))); + } else { + const parsed: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.Result => { + const b3: rt.u8 = _2; + if (!(b3 < 240)) { + return rt.Err(b3); } + return rt.Ok(b3); + }), (values__: rt.Iter) => rt.iterToByteVec(values__)); + if (parsed.ok) { + rt.byteVecExtendFromSlice(out, rt.byteVecView(parsed.value)); + } else { + rt.byteVecPush(out, parsed.error); } + rt.byteVecPush(out, rt.optionMapOr(rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_24: rt.u8): void => { + rt.byteVecPush(log, _24); + }), (_29: rt.u8): rt.u16 | undefined => { + const b5: rt.u8 = _29; + return rt.thenSome(b5 !== 32, b5 as rt.u16); + }), (values__: rt.Iter) => rt.iterToArray(values__)), 255, (v2: rt.u16[]): rt.u8 => { + return v2.length & 0xff; + })); } rt.byteVecExtendFromSlice(out, rt.byteVecView(log)); } @@ -343,91 +339,93 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _37: rt.u8 | rt.Done = iter.next(); if (_37 === rt.DONE) { - const iter2: rt.Iter = rt.iterStepBy(rt.iterSkip(new rt.Range(a, b), 1), 4); - while (true) { - const _47: rt.u8 | rt.Done = iter2.next(); - if (_47 === rt.DONE) { - const _56: rt.Range = new rt.Range(a, b); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_56, 5), 238)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)))); - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); - rt.byteVecPush(out, rt.rangeInclusiveContains(inclusive, b) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(new rt.RangeInclusive(32, 127, rt.u64Step), a as rt.u64) ? 1 : 0); - const near: rt.RangeInclusive = new rt.RangeInclusive(rt.max(a, 200), 255, rt.u8Step); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(near, b as rt.usize), 238)); - rt.byteVecPush(out, rt.rangeInclusiveStart(near)); - rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(near) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(near, 255) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(near, 100) ? 1 : 0); - const low: rt.RangeInclusive = new rt.RangeInclusive(0, b, rt.u8Step); - const _113: rt.usize = rt.usizeRem(a as rt.usize, 16); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(low.nthBackItem(_113)), 238)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(low)); - const _125: rt.u8 = rt.u8Div(b, 2); - rt.byteVecPush(out, rt.rangeInclusiveContains(low, _125) ? 1 : 0); - const reversed: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - const _132: rt.Iter = rt.iterRev(reversed); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_132, a as rt.usize), 238)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(reversed)); - rt.byteVecPush(out, rt.rangeInclusiveContains(reversed, a) ? 1 : 0); - const counted: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(new rt.RangeInclusive(a, b, rt.u8Step)); - const _152: rt.usize = rt.usizeDiv(b as rt.usize, 4); - const _149: [rt.usize, rt.u8] = rt.optionUnwrapOr(rt.iterNth(counted, _152), [221, 221] as [rt.usize, rt.u8]); - const i3: rt.usize = _149[0]; - const n: rt.u8 = _149[1]; - rt.byteVecPush(out, i3 & 0xff); - rt.byteVecPush(out, n); - rt.byteVecPush(out, rt.optionMapOr(rt.iterToOption(counted.next()), 204, (_2: [rt.usize, rt.u8]): rt.u8 => { - return _2[0] & 0xff; - })); - const stepped: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.iterCount(rt.iterStepBy(stepped, 3)) & 0xff); - rt.byteVecPush(out, rt.rangeInclusiveStart(stepped)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(new rt.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rt.i8Step)), (i5: rt.i8): rt.u8 => { - return i5 & 0xff; - })); - const wide: rt.Range = new rt.Range(a as rt.u64, rt.u64Mul(b as rt.u64, 3), rt.u64Step); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(wide, (n2: rt.u64): rt.u64 => { - return rt.u64Rem(n2, 5); - }), (_23: rt.u64): boolean => { - return _23 === 0; - })) & 0xff); - rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0))); - const edge: rt.u64 = rt.u64Add(rt.u64Sub(rt.u64Of(9007199254740992n), 2), rt.u64Rem(a as rt.u64, 4)); - const past: rt.Range = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); - const _223: rt.usize = rt.usizeRem(b as rt.usize, 3); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _223), 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0))); - const _240: rt.RangeInclusive = new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step); - const _243: rt.usize = rt.usizeRem(b as rt.usize, 5); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_240, _243), 0))); - const _250: rt.u64 = rt.u64Rem(a as rt.u64, 3); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), _250), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { - return rt.u64Rem(n4, 7); - }), rt.u64Add, 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { - return _24; - }), 0))); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Add(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Step)), 0))); - const iterS: rt.u32[] = rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))); - let iterI: number = 0; - while (true) { - const _295: rt.u32 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_295 === rt.DONE) { - updates(a, b, data, out); - return; - } - rt.byteVecPush(out, _295 & 0xff); - } - } - rt.byteVecPush(out, _47); - } + break; } rt.byteVecPush(out, _37); } + const iter2: rt.Iter = rt.iterStepBy(rt.iterSkip(new rt.Range(a, b), 1), 4); + while (true) { + const _47: rt.u8 | rt.Done = iter2.next(); + if (_47 === rt.DONE) { + break; + } + rt.byteVecPush(out, _47); + } + const _56: rt.Range = new rt.Range(a, b); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_56, 5), 238)); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)))); + const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); + rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); + rt.byteVecPush(out, rt.rangeInclusiveContains(inclusive, b) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(new rt.RangeInclusive(32, 127, rt.u64Step), a as rt.u64) ? 1 : 0); + const near: rt.RangeInclusive = new rt.RangeInclusive(rt.max(a, 200), 255, rt.u8Step); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(near, b as rt.usize), 238)); + rt.byteVecPush(out, rt.rangeInclusiveStart(near)); + rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(near) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(near, 255) ? 1 : 0); + rt.byteVecPush(out, rt.rangeInclusiveContains(near, 100) ? 1 : 0); + const low: rt.RangeInclusive = new rt.RangeInclusive(0, b, rt.u8Step); + const _113: rt.usize = rt.usizeRem(a as rt.usize, 16); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(low.nthBackItem(_113)), 238)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(low)); + const _125: rt.u8 = rt.u8Div(b, 2); + rt.byteVecPush(out, rt.rangeInclusiveContains(low, _125) ? 1 : 0); + const reversed: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); + const _132: rt.Iter = rt.iterRev(reversed); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_132, a as rt.usize), 238)); + rt.byteVecPush(out, rt.rangeInclusiveEnd(reversed)); + rt.byteVecPush(out, rt.rangeInclusiveContains(reversed, a) ? 1 : 0); + const counted: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(new rt.RangeInclusive(a, b, rt.u8Step)); + const _152: rt.usize = rt.usizeDiv(b as rt.usize, 4); + const _149: [rt.usize, rt.u8] = rt.optionUnwrapOr(rt.iterNth(counted, _152), [221, 221] as [rt.usize, rt.u8]); + const i3: rt.usize = _149[0]; + const n: rt.u8 = _149[1]; + rt.byteVecPush(out, i3 & 0xff); + rt.byteVecPush(out, n); + rt.byteVecPush(out, rt.optionMapOr(rt.iterToOption(counted.next()), 204, (_2: [rt.usize, rt.u8]): rt.u8 => { + return _2[0] & 0xff; + })); + const stepped: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); + rt.byteVecPush(out, rt.iterCount(rt.iterStepBy(stepped, 3)) & 0xff); + rt.byteVecPush(out, rt.rangeInclusiveStart(stepped)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(new rt.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rt.i8Step)), (i5: rt.i8): rt.u8 => { + return i5 & 0xff; + })); + const wide: rt.Range = new rt.Range(a as rt.u64, rt.u64Mul(b as rt.u64, 3), rt.u64Step); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(wide, (n2: rt.u64): rt.u64 => { + return rt.u64Rem(n2, 5); + }), (_23: rt.u64): boolean => { + return _23 === 0; + })) & 0xff); + rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0))); + const edge: rt.u64 = rt.u64Add(rt.u64Sub(rt.u64Of(9007199254740992n), 2), rt.u64Rem(a as rt.u64, 4)); + const past: rt.Range = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); + const _223: rt.usize = rt.usizeRem(b as rt.usize, 3); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _223), 0))); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0))); + const _240: rt.RangeInclusive = new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step); + const _243: rt.usize = rt.usizeRem(b as rt.usize, 5); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_240, _243), 0))); + const _250: rt.u64 = rt.u64Rem(a as rt.u64, 3); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub(rt.u64Of(18446744073709551615n), _250), rt.u64Of(18446744073709551615n), rt.u64Step), (n4: rt.u64): rt.u64 => { + return rt.u64Rem(n4, 7); + }), rt.u64Add, 0))); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { + return _24; + }), 0))); + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Add(rt.i64Neg(rt.i64Of(9007199254740992n)), 1), rt.i64Step)), 0))); + const iterS: rt.u32[] = rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))); + let iterI: number = 0; + while (true) { + const _295: rt.u32 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_295 === rt.DONE) { + break; + } + rt.byteVecPush(out, _295 & 0xff); + } + updates(a, b, data, out); } /** @@ -446,36 +444,33 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): rt.byteVecExtendFromSlice(out, Uint8Array.of(made.start, _7, whole.start, whole.end)); let iterStart: rt.u8 = rt.u8Div(a, 2); const iterEnd: rt.u8 = base.end; - while (true) { - if (!((_29 = iterStart++) < iterEnd)) { - rt.byteVecPush(out, base.end); - const len: rt.usize = data.length; - const _41: [rt.usize, rt.usize] = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)]; - const to: rt.usize = _41[0]; - const from: rt.usize = _41[1]; - const all: rt.Range = new rt.Range(0, len); - rt.byteVecPush(out, 210); - rt.byteVecPush(out, 211); - rt.byteVecPush(out, 212); - rt.byteVecExtendFromSlice(out, rt.sliceRange(data, from, rt.rangeClone(all).end)); - rt.byteVecPush(out, 213); - rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); - rt.byteVecPush(out, 214); - rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); - fullRange(out); - rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); - rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); - const copied: rt.ByteVec = rt.sliceToByteVec(data); - const _76: Uint8Array = rt.byteVecView(copied); - rt.sliceCopyWithin(_76, 0, to, 0); - rt.byteVecExtendFromSlice(out, rt.byteVecView(copied)); - return; - } + while ((_29 = iterStart++) < iterEnd) { const i: rt.u8 = _29; const _33: rt.u8 = rt.u8WrappingAdd(base.end, 1); base.end = _33; rt.byteVecPush(out, i); } + rt.byteVecPush(out, base.end); + const len: rt.usize = data.length; + const _41: [rt.usize, rt.usize] = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)]; + const to: rt.usize = _41[0]; + const from: rt.usize = _41[1]; + const all: rt.Range = new rt.Range(0, len); + rt.byteVecPush(out, 210); + rt.byteVecPush(out, 211); + rt.byteVecPush(out, 212); + rt.byteVecExtendFromSlice(out, rt.sliceRange(data, from, rt.rangeClone(all).end)); + rt.byteVecPush(out, 213); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, 214); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + fullRange(out); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + const copied: rt.ByteVec = rt.sliceToByteVec(data); + const _76: Uint8Array = rt.byteVecView(copied); + rt.sliceCopyWithin(_76, 0, to, 0); + rt.byteVecExtendFromSlice(out, rt.byteVecView(copied)); } /** `..`, logging that it was made. */ @@ -501,47 +496,7 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _15: rt.u8 | undefined | rt.Done = iter.next(); if (_15 === rt.DONE) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(data), (b4: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b4, 3) === 0)) { - return b4; - } - return undefined; - }), (value: rt.u8 | undefined) => rt.iterOption(value))))); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { - return o !== undefined; - })) & 0xff); - rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(data), (b5: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b5, 3) === 0)) { - return b5; - } - return undefined; - })), 205)); - const first: rt.u8 | undefined = rt.sliceFirst(data); - const iter2: rt.Iter = rt.iterChain(rt.iterOption(first), rt.iterOnce(153)); - while (true) { - const _49: rt.u8 | rt.Done = iter2.next(); - if (_49 === rt.DONE) { - const _57: rt.Iter = rt.iterOption(first); - rt.iterEmpty(); - rt.iterExtendBytes(out, rt.iterChain(_57, rt.iterEmpty())); - let n: rt.u8 = 0; - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { - n = rt.u8Add(n, 1); - return rt.thenSome(n < 4, n); - })))); - const iter3: Gaps.Gaps = { data, at: 0 }; - while (true) { - const _70: rt.u8 | undefined | rt.Done = Gaps.next$Iterator(iter3); - if (_70 === rt.DONE) { - return; - } - rt.byteVecPush(out, rt.optionMapOr(_70, 170, (b6: rt.u8): rt.u8 => { - return b6; - })); - } - } - rt.byteVecPush(out, _49); - } + break; } const item: rt.u8 | undefined = _15; if (item === undefined) { @@ -550,6 +505,48 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, item); } } + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(data), (b4: rt.u8): rt.u8 | undefined => { + if (!(rt.u8Rem(b4, 3) === 0)) { + return b4; + } + return undefined; + }), (value: rt.u8 | undefined) => rt.iterOption(value))))); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { + return o !== undefined; + })) & 0xff); + rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(data), (b5: rt.u8): rt.u8 | undefined => { + if (!(rt.u8Rem(b5, 3) === 0)) { + return b5; + } + return undefined; + })), 205)); + const first: rt.u8 | undefined = rt.sliceFirst(data); + const iter2: rt.Iter = rt.iterChain(rt.iterOption(first), rt.iterOnce(153)); + while (true) { + const _49: rt.u8 | rt.Done = iter2.next(); + if (_49 === rt.DONE) { + break; + } + rt.byteVecPush(out, _49); + } + const _57: rt.Iter = rt.iterOption(first); + rt.iterEmpty(); + rt.iterExtendBytes(out, rt.iterChain(_57, rt.iterEmpty())); + let n: rt.u8 = 0; + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { + n = rt.u8Add(n, 1); + return rt.thenSome(n < 4, n); + })))); + const iter3: Gaps.Gaps = { data, at: 0 }; + while (true) { + const _70: rt.u8 | undefined | rt.Done = Gaps.next$Iterator(iter3); + if (_70 === rt.DONE) { + break; + } + rt.byteVecPush(out, rt.optionMapOr(_70, 170, (b6: rt.u8): rt.u8 => { + return b6; + })); + } } /** The second item of an iterator of options, through `?`, which tests for its end. */ @@ -573,29 +570,31 @@ export function own(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _13: rt.u8 | rt.Done = Countdown.next$Iterator(iter); if (_13 === rt.DONE) { - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { - return rt.u64Div(rt.u64Mul(n3 as rt.u64, 1000), 7); - }), rt.u64Add, 0))); - const down: Countdown.Countdown = { left, step }; - l1: while (true) { - const _26: rt.u8 | rt.Done = Countdown.next$Iterator(down); - if (_26 !== rt.DONE) { - if (!(rt.u8Rem(_26, 5) === 0)) { - continue l1; - } - } - rt.byteVecPush(out, down.left); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(data) }, (it: Evens.Evens) => Evens.next$Iterator(it))))); - const byRef: Evens.Evens = { inner: rt.iterSlice(rt.sliceRange(data, rt.min(data.length, 1))) }; - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)))); - rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 4294967297) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0))); - return; - } + break; } rt.byteVecPush(out, _13); } + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { + return rt.u64Div(rt.u64Mul(n3 as rt.u64, 1000), 7); + }), rt.u64Add, 0))); + const down: Countdown.Countdown = { left, step }; + while (true) { + const _26: rt.u8 | rt.Done = Countdown.next$Iterator(down); + if (_26 !== rt.DONE) { + if (rt.u8Rem(_26, 5) === 0) { + break; + } + } else { + break; + } + } + rt.byteVecPush(out, down.left); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(data) }, (it: Evens.Evens) => Evens.next$Iterator(it))))); + const byRef: Evens.Evens = { inner: rt.iterSlice(rt.sliceRange(data, rt.min(data.length, 1))) }; + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)))); + rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); + rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))))); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 4294967297) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0))); } /** @@ -619,58 +618,61 @@ export function values(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _8: rt.u8 | rt.Done = iter.next(); if (_8 === rt.DONE) { - const held: Held.Held = { it: rt.iterSlice(data) }; - rt.byteVecPush(out, Held.skipOne(held)); - const iter2: rt.Iter = odds(data); - while (true) { - const _21: rt.u8 | rt.Done = iter2.next(); - if (_21 === rt.DONE) { - [{ _0: data }, { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }] as [Doubled.Doubled, Doubled.Doubled]; - const arg = { _0: data }; - const _39: rt.Fmt = (f: rt.Formatter) => Doubled.fmt$Debug(arg, f); - const arg2 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; - const args2: rt.Fmt[] = [_39, (f: rt.Formatter) => Doubled.fmt$Debug(arg2, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1])]))); - const tags: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tag.Tag => { - const b3: rt.u8 = _2; - return { bytes: rt.sliceToByteVec(Uint8Array.of(b3, ~b3 & 0xff)) }; - })); - const cloned: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); - const iter3: rt.Iter = rt.iterSlice(cloned); - while (true) { - const _59: Tag.Tag | rt.Done = iter3.next(); - if (_59 === rt.DONE) { - const iter4: rt.Iter = rt.iterChain(rt.iterSlice(tags), rt.iterSlice(cloned)); - while (true) { - const _74: Tag.Tag | rt.Done = iter4.next(); - if (_74 === rt.DONE) { - const bumps: Bumped.Bumped[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_22: rt.u8): Bumped.Bumped => { - return { _0: _22 }; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { - return b5._0; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), rt.copy), (b6: Bumped.Bumped): rt.u8 => { - return b6._0; - })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_23: rt.u8): Wrapper.Wrapper => { - return new Wrapper.Wrapper({ _0: _23 }); - }))), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { - return w._0._0; - })); - return; - } - rt.byteVecExtendFromSlice(out, rt.byteVecView(_74.bytes)); - } - } - rt.byteVecPush(_59.bytes, 119); - } - } - rt.byteVecPush(out, _21); - } + break; } rt.byteVecPush(out, _8); } + const held: Held.Held = { it: rt.iterSlice(data) }; + rt.byteVecPush(out, Held.skipOne(held)); + const iter2: rt.Iter = odds(data); + while (true) { + const _21: rt.u8 | rt.Done = iter2.next(); + if (_21 === rt.DONE) { + break; + } + rt.byteVecPush(out, _21); + } + [{ _0: data }, { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }] as [Doubled.Doubled, Doubled.Doubled]; + const arg = { _0: data }; + const _39: rt.Fmt = (f: rt.Formatter) => Doubled.fmt$Debug(arg, f); + const arg2 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; + const args2: rt.Fmt[] = [_39, (f: rt.Formatter) => Doubled.fmt$Debug(arg2, f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1])]))); + const tags: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tag.Tag => { + const b3: rt.u8 = _2; + return { bytes: rt.sliceToByteVec(Uint8Array.of(b3, ~b3 & 0xff)) }; + })); + const cloned: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); + const iter3: rt.Iter = rt.iterSlice(cloned); + while (true) { + const _59: Tag.Tag | rt.Done = iter3.next(); + if (_59 === rt.DONE) { + break; + } + rt.byteVecPush(_59.bytes, 119); + } + const iter4: rt.Iter = rt.iterChain(rt.iterSlice(tags), rt.iterSlice(cloned)); + while (true) { + const _74: Tag.Tag | rt.Done = iter4.next(); + if (_74 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.byteVecView(_74.bytes)); + } + const bumps: Bumped.Bumped[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_22: rt.u8): Bumped.Bumped => { + return { _0: _22 }; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { + return b5._0; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), rt.copy), (b6: Bumped.Bumped): rt.u8 => { + return b6._0; + })); + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_23: rt.u8): Wrapper.Wrapper => { + return new Wrapper.Wrapper({ _0: _23 }); + }))), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { + return w._0._0; + })); } //# sourceMappingURL=iters.ts.map diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index ef33b154a..1dd178e3a 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -118,49 +118,49 @@ export function partial(o: rt.Ordering | undefined): rt.u8 { /** The index of the first of `keys` that borrows as `q`. */ export function find$Arc_str_str(keys_: rt.Arc[], q: string): rt.u8 { const iter: rt.Iter<[rt.usize, rt.Arc]> = rt.iterEnumerate(rt.iterSlice(keys_)); - l0: while (true) { + while (true) { const _7: [rt.usize, rt.Arc] | rt.Done = iter.next(); if (_7 === rt.DONE) { - return 255; + break; } const i: rt.usize = _7[0]; - if (!((_7[1].value === q))) { - continue l0; + if (_7[1].value === q) { + return i & 0xff; } - return i & 0xff; } + return 255; } /** The index of the first of `keys` that borrows as `q`. */ export function find$String_str(keys_: string[], q: string): rt.u8 { const iter: rt.Iter<[rt.usize, string]> = rt.iterEnumerate(rt.iterSlice(keys_)); - l0: while (true) { + while (true) { const _7: [rt.usize, string] | rt.Done = iter.next(); if (_7 === rt.DONE) { - return 255; + break; } const i: rt.usize = _7[0]; - if (!((_7[1] === q))) { - continue l0; + if (_7[1] === q) { + return i & 0xff; } - return i & 0xff; } + return 255; } /** The index of the first of `keys` that borrows as `q`. */ export function find$u8_u8(keys_: Uint8Array, q: rt.u8): rt.u8 { const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(keys_)); - l0: while (true) { + while (true) { const _7: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_7 === rt.DONE) { - return 255; + break; } const i: rt.usize = _7[0]; - if (!((_7[1] === q))) { - continue l0; + if (_7[1] === q) { + return i & 0xff; } - return i & 0xff; } + return 255; } /** Run one case. */ @@ -191,23 +191,7 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { const ways: rt.HashMap<[Way.Way | undefined, boolean], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashOption(Way.hash$Hash_DefaultHasher), rt.hashInt]), rt.eqTuple([rt.eqOption(Way.eq$PartialEq), rt.same]))) as rt.HashMap<[Way.Way | undefined, boolean], rt.u8>; let iterStart: rt.usize = 1; const iterEnd: rt.usize = data.length; - while (true) { - if (!((_10 = iterStart++) < iterEnd)) { - const iter2: rt.Iter<[[rt.u8, Horizon.Horizon], rt.u8]> = rt.btreeIter(sorted); - while (true) { - const _310: [[rt.u8, Horizon.Horizon], rt.u8] | rt.Done = iter2.next(); - if (_310 === rt.DONE) { - return; - } - rt.byteVecPush(out, _310[0][0]); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(_310[0][1].exclude, 0, (h4: Hop.Hop): rt.u64 => { - return h4._0; - }))); - rt.byteVecPush(out, (_310[0][1].exclude !== undefined ? 1 : 0) | (((_310[0][1].local ? 1 : 0) << 1) & 0xff)); - rt.byteVecPush(out, _310[1]); - rt.byteVecPush(out, rt.hashIndex(hashed, [_310[0][0], rt.copy(_310[0][1])] as [rt.u8, Horizon.Horizon])); - } - } + while ((_10 = iterStart++) < iterEnd) { const i: rt.usize = _10; const _18: rt.usize = rt.usizeSub(i, 1); rt.idx(data, _18); @@ -293,10 +277,24 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { unwind = 0; rt.drop(m); } + const iter2: rt.Iter<[[rt.u8, Horizon.Horizon], rt.u8]> = rt.btreeIter(sorted); + while (true) { + const _310: [[rt.u8, Horizon.Horizon], rt.u8] | rt.Done = iter2.next(); + if (_310 === rt.DONE) { + break; + } + rt.byteVecPush(out, _310[0][0]); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(_310[0][1].exclude, 0, (h4: Hop.Hop): rt.u64 => { + return h4._0; + }))); + rt.byteVecPush(out, (_310[0][1].exclude !== undefined ? 1 : 0) | (((_310[0][1].local ? 1 : 0) << 1) & 0xff)); + rt.byteVecPush(out, _310[1]); + rt.byteVecPush(out, rt.hashIndex(hashed, [_310[0][0], rt.copy(_310[0][1])] as [rt.u8, Horizon.Horizon])); + } } catch (e) { - b2: { - b3: { - b4: { + b4: { + b5: { + b6: { if (unwind === 0) { throw e; } @@ -305,16 +303,16 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { } else if (unwind !== 134) { if (unwind === 135) { rt.drop(_229); - break b4; + break b6; } if (unwind === 136) { - break b4; + break b6; } if (unwind === 137) { - break b3; + break b5; } rt.drop(_148); - break b2; + break b4; } rt.drop(r); } @@ -346,37 +344,7 @@ export function arcs(data: Uint8Array, out: rt.ByteVec): void { _165 = false; let iterStart: rt.usize = 1; const iterEnd: rt.usize = data.length; - while (true) { - if (!((_7 = iterStart++) < iterEnd)) { - const _130: rt.u8 | undefined = rt.sliceFirst(data); - if (_130 !== undefined) { - rt.byteVecPush(out, find$u8_u8(data, _130)); - } - liar = new rt.Arc({}); - unwind = 76; - never = new rt.Arc({}); - unwind = 75; - _145 = rt.arcClone(liar); - unwind = 74; - const _141: rt.u8 = rt.eqArc(Liar.eq$PartialEq, true)(liar, _145) ? 1 : 0; - _152 = rt.arcClone(never); - unwind = 73; - const _140: rt.u8 = _141 | (((rt.eqArc(Never.eq$PartialEq)(never, _152) ? 1 : 0) << 1) & 0xff); - _161 = new rt.Arc({}); - unwind = 72; - rt.byteVecPush(out, _140 | (((rt.eqArc(Liar.eq$PartialEq, true)(liar, _161) ? 1 : 0) << 2) & 0xff)); - unwind = 73; - rt.drop(_161); - unwind = 74; - rt.drop(_152); - unwind = 75; - rt.drop(_145); - unwind = 76; - rt.drop(never); - unwind = 0; - rt.drop(liar); - return; - } + while ((_7 = iterStart++) < iterEnd) { const i: rt.usize = _7; const _16: rt.usize = rt.usizeSub(i, 1); rt.idx(data, _16); @@ -419,30 +387,57 @@ export function arcs(data: Uint8Array, out: rt.ByteVec): void { _165 = false; _166 = false; } + const _130: rt.u8 | undefined = rt.sliceFirst(data); + if (_130 !== undefined) { + rt.byteVecPush(out, find$u8_u8(data, _130)); + } + liar = new rt.Arc({}); + unwind = 76; + never = new rt.Arc({}); + unwind = 75; + _145 = rt.arcClone(liar); + unwind = 74; + const _141: rt.u8 = rt.eqArc(Liar.eq$PartialEq, true)(liar, _145) ? 1 : 0; + _152 = rt.arcClone(never); + unwind = 73; + const _140: rt.u8 = _141 | (((rt.eqArc(Never.eq$PartialEq)(never, _152) ? 1 : 0) << 1) & 0xff); + _161 = new rt.Arc({}); + unwind = 72; + rt.byteVecPush(out, _140 | (((rt.eqArc(Liar.eq$PartialEq, true)(liar, _161) ? 1 : 0) << 2) & 0xff)); + unwind = 73; + rt.drop(_161); + unwind = 74; + rt.drop(_152); + unwind = 75; + rt.drop(_145); + unwind = 76; + rt.drop(never); + unwind = 0; + rt.drop(liar); } catch (e) { - b2: { - b3: { - b4: { - b5: { - b6: { + b3: { + b4: { + b5: { + b6: { + b7: { if (unwind === 0) { throw e; } if (unwind === 72) { rt.drop(_161); - break b6; + break b7; } if (unwind === 73) { - break b6; + break b7; } if (unwind === 74) { - break b5; + break b6; } if (unwind === 75) { - break b4; + break b5; } if (unwind === 76) { - break b3; + break b4; } if (unwind === 77) { rt.dropAll(_127); @@ -450,7 +445,7 @@ export function arcs(data: Uint8Array, out: rt.ByteVec): void { if (unwind !== 79) { if (unwind === 81) { rt.drop(_14); - break b2; + break b3; } } } @@ -458,10 +453,10 @@ export function arcs(data: Uint8Array, out: rt.ByteVec): void { rt.drop(b.text); } if (!_166) { - break b2; + break b3; } rt.drop(a.text); - break b2; + break b3; } rt.drop(_152); } @@ -491,88 +486,7 @@ export function places(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _11: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_11 === rt.DONE) { - const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _150: rt.usize = rt.usizeMul(data.length, 4); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _150; - while (true) { - if (!((_154 = iterStart++) < iterEnd)) { - const iter3: rt.Iter<[rt.u16, rt.u16]> = rt.btreeIter(tree); - while (true) { - const _179: [rt.u16, rt.u16] | rt.Done = iter3.next(); - if (_179 === rt.DONE) { - const touchy: rt.BTreeMap = rt.btreeNew(Touchy.cmp$Ord) as rt.BTreeMap; - const place16 = rt.entryOrInsertWithMut(rt.entry(touchy, { _0: data.length & 0xff }), (): rt.u8 => { - return 7; - }); - place16.v = rt.u8Add(place16.v, 1); - const hashy: rt.HashMap = rt.hashNew(rt.hashing(Touchy.hash$Hash_DefaultHasher, Touchy.eq$PartialEq)) as rt.HashMap; - const place17 = rt.entryOrInsertWithMut(rt.entry(hashy, { _0: data.length & 0xff }), (): rt.u8 => { - return 0; - }); - place17.v = rt.u8Add(place17.v, 2); - rt.iterExtendBytes(out, rt.iterChain(rt.btreeValues(touchy), rt.hashValues(hashy))); - const place18 = rt.entryOrInsertWithMut(rt.entry(counts, 0), (): rt.usize => { - return 0; - }); - const bump: () => void = (): void => { - place18.v = rt.usizeAdd(place18.v, 1); - }; - bump(); - const spare: rt.usize[] = [data.length, 8]; - const place19 = rt.entryOrInsertMut(rt.entry(counts, 1), 3); - const swapped = place19.v; - place19.v = spare[0]; - spare[0] = swapped; - const place20 = rt.entryOrInsertWithMut(rt.entry(counts, 2), (): rt.usize => { - return 0; - }); - place20.v = rt.usizeAdd(place20.v, spare[0]); - const iter4: rt.Iter<[rt.u8, rt.usize]> = rt.btreeIter(counts); - while (true) { - const _241: [rt.u8, rt.usize] | rt.Done = iter4.next(); - if (_241 === rt.DONE) { - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 7; - while (true) { - if (!((_257 = iterStart2++) < iterEnd2)) { - const iter6: rt.Range = new rt.Range(0, 6, rt.u64Step); - while (true) { - const _273: rt.u64 | rt.Done = iter6.next(); - if (_273 === rt.DONE) { - const iter7: rt.Iter<[Hop.Hop, [rt.u8, rt.u8]]> = rt.btreeIter(pairs); - while (true) { - const _290: [Hop.Hop, [rt.u8, rt.u8]] | rt.Done = iter7.next(); - if (_290 === rt.DONE) { - return; - } - rt.byteVecPush(out, rt.u64Low(_290[0]._0) & 0xff); - rt.byteVecPush(out, _290[1][0]); - rt.byteVecPush(out, _290[1][1]); - } - } - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.optionUnwrapOr(rt.hashGet(hops, { _0: _273 }), 0))); - } - } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.hashGet(wide, _257), 0))); - } - } - rt.byteVecPush(out, _241[0]); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(_241[1] as rt.u32)); - } - } - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_179[0])); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_179[1])); - } - } - const j: rt.usize = _154; - const _159: rt.usize = rt.usizeRem(j, data.length); - rt.idx(data, _159); - const b2: rt.u8 = data[_159]; - const _167: rt.u16 = rt.u16Mul(j & 0xffff, 37) ^ b2 as rt.u16; - const place15 = rt.entryOrInsertMut(rt.entry(tree, _167), j & 0xffff); - place15.v = rt.u16WrappingAdd(place15.v, b2 as rt.u16); - } + break; } const i: rt.usize = _11[0]; const b: rt.u8 = _11[1]; @@ -656,6 +570,87 @@ export function places(data: Uint8Array, out: rt.ByteVec): void { place14.v[0] = _144; place14.v[1] = place14.v[1] ^ place14.v[0]; } + const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; + const _150: rt.usize = rt.usizeMul(data.length, 4); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = _150; + while ((_154 = iterStart++) < iterEnd) { + const j: rt.usize = _154; + const _159: rt.usize = rt.usizeRem(j, data.length); + rt.idx(data, _159); + const b2: rt.u8 = data[_159]; + const _167: rt.u16 = rt.u16Mul(j & 0xffff, 37) ^ b2 as rt.u16; + const place15 = rt.entryOrInsertMut(rt.entry(tree, _167), j & 0xffff); + place15.v = rt.u16WrappingAdd(place15.v, b2 as rt.u16); + } + const iter3: rt.Iter<[rt.u16, rt.u16]> = rt.btreeIter(tree); + while (true) { + const _179: [rt.u16, rt.u16] | rt.Done = iter3.next(); + if (_179 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_179[0])); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_179[1])); + } + const touchy: rt.BTreeMap = rt.btreeNew(Touchy.cmp$Ord) as rt.BTreeMap; + const place16 = rt.entryOrInsertWithMut(rt.entry(touchy, { _0: data.length & 0xff }), (): rt.u8 => { + return 7; + }); + place16.v = rt.u8Add(place16.v, 1); + const hashy: rt.HashMap = rt.hashNew(rt.hashing(Touchy.hash$Hash_DefaultHasher, Touchy.eq$PartialEq)) as rt.HashMap; + const place17 = rt.entryOrInsertWithMut(rt.entry(hashy, { _0: data.length & 0xff }), (): rt.u8 => { + return 0; + }); + place17.v = rt.u8Add(place17.v, 2); + rt.iterExtendBytes(out, rt.iterChain(rt.btreeValues(touchy), rt.hashValues(hashy))); + const place18 = rt.entryOrInsertWithMut(rt.entry(counts, 0), (): rt.usize => { + return 0; + }); + const bump: () => void = (): void => { + place18.v = rt.usizeAdd(place18.v, 1); + }; + bump(); + const spare: rt.usize[] = [data.length, 8]; + const place19 = rt.entryOrInsertMut(rt.entry(counts, 1), 3); + const swapped = place19.v; + place19.v = spare[0]; + spare[0] = swapped; + const place20 = rt.entryOrInsertWithMut(rt.entry(counts, 2), (): rt.usize => { + return 0; + }); + place20.v = rt.usizeAdd(place20.v, spare[0]); + const iter4: rt.Iter<[rt.u8, rt.usize]> = rt.btreeIter(counts); + while (true) { + const _241: [rt.u8, rt.usize] | rt.Done = iter4.next(); + if (_241 === rt.DONE) { + break; + } + rt.byteVecPush(out, _241[0]); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(_241[1] as rt.u32)); + } + let iterStart2: rt.u8 = 0; + const iterEnd2: rt.u8 = 7; + while ((_257 = iterStart2++) < iterEnd2) { + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.hashGet(wide, _257), 0))); + } + const iter6: rt.Range = new rt.Range(0, 6, rt.u64Step); + while (true) { + const _273: rt.u64 | rt.Done = iter6.next(); + if (_273 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.optionUnwrapOr(rt.hashGet(hops, { _0: _273 }), 0))); + } + const iter7: rt.Iter<[Hop.Hop, [rt.u8, rt.u8]]> = rt.btreeIter(pairs); + while (true) { + const _290: [Hop.Hop, [rt.u8, rt.u8]] | rt.Done = iter7.next(); + if (_290 === rt.DONE) { + break; + } + rt.byteVecPush(out, rt.u64Low(_290[0]._0) & 0xff); + rt.byteVecPush(out, _290[1][0]); + rt.byteVecPush(out, _290[1][1]); + } } //# sourceMappingURL=keys.ts.map diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 2681f3c4c..80dd21579 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -112,68 +112,68 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _42: rt.i32 | rt.Done = iter.next(); if (_42 === rt.DONE) { - rt.byteVecPush(out, saved[1]); - rt.byteVecPush(out, pair[1]); - rt.byteVecPush(out, Point.eq$PartialEq(p, saved[0]) ? 1 : 0); - let a: Point.Point = rt.copy(Point.new(1, 2)); - let b: Point.Point = rt.copy(Point.new(3, 4)); - const swapped = a; - a = b; - b = swapped; - const _66: Point.Point = Point.new(5, 6); - const old2 = a; - a = rt.copy(_66); - const old: Point.Point = old2; - const _71: rt.u8 = a.x & 0xff; - const _73: rt.u8 = b.x & 0xff; - rt.byteVecExtendFromSlice(out, Uint8Array.of(_71, _73, old.x & 0xff)); - const boxed: Moved.Moved = { _0: data.length & 0xff, _1: 0 }; - const _81: rt.u16 = rt.u16Add(boxed._1, 1); - const _198: Moved.Moved = boxed; - _198._1 = _81; - const _83: rt.u16 = rt.u16Add(boxed._1, 2); - const _195: Moved.Moved = boxed; - _195._1 = _83; - rt.byteVecExtendFromSlice(out, Uint8Array.of(boxed._0)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(boxed._1)); - let n: rt.u32 = data.length as rt.u32; - const both: [rt.u32, rt.u32] = [n, n]; - n = 9; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n))); - const word: Uint8Array = Uint8Array.of(0, 0, 0, data.length & 0xff); - const converted: rt.u32 = rt.u32FromBeBytes(word); - word[0] = 9; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32))); - const cell: Uint8Array = Uint8Array.of(data.length & 0xff); - rt.byteVecPush(out, writeThenRead(rt.copy(cell), cell)); - const source: Uint8Array = Uint8Array.of(data.length & 0xff); - const returned: Uint8Array = same(rt.copy(source)); - source[0] = 9; - const _145: rt.u8 = returned[0]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(_145, source[0])); - rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); - const marked: boolean = mark(out, 1) === 0; - mark(out, 2); - rt.byteVecPush(out, marked ? 1 : 0); - let opt: Meters.Meters | undefined = rt.copy({ _0: 9 }); - const taken2 = opt; - opt = undefined; - const taken: Meters.Meters | undefined = taken2; - rt.byteVecPush(out, opt === undefined ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(taken, 0, (m: Meters.Meters): rt.u64 => { - return m._0; - }))); - const res: rt.Result = rt.Ok(p); - const first: Point.Point = rt.copy(rt.resultUnwrap(res, rt.u8Display)); - first.x = 2; - const fail: rt.Result = rt.Err(rt.copy(q)); - const err: Point.Point = rt.copy(rt.resultUnwrapErr(fail, rt.u8Display)); - err.y = 3; - rt.byteVecExtendFromSlice(out, Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Display).y & 0xff)); - return; + break; } rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(_42)); } + rt.byteVecPush(out, saved[1]); + rt.byteVecPush(out, pair[1]); + rt.byteVecPush(out, Point.eq$PartialEq(p, saved[0]) ? 1 : 0); + let a: Point.Point = rt.copy(Point.new(1, 2)); + let b: Point.Point = rt.copy(Point.new(3, 4)); + const swapped = a; + a = b; + b = swapped; + const _66: Point.Point = Point.new(5, 6); + const old2 = a; + a = rt.copy(_66); + const old: Point.Point = old2; + const _71: rt.u8 = a.x & 0xff; + const _73: rt.u8 = b.x & 0xff; + rt.byteVecExtendFromSlice(out, Uint8Array.of(_71, _73, old.x & 0xff)); + const boxed: Moved.Moved = { _0: data.length & 0xff, _1: 0 }; + const _81: rt.u16 = rt.u16Add(boxed._1, 1); + const _198: Moved.Moved = boxed; + _198._1 = _81; + const _83: rt.u16 = rt.u16Add(boxed._1, 2); + const _195: Moved.Moved = boxed; + _195._1 = _83; + rt.byteVecExtendFromSlice(out, Uint8Array.of(boxed._0)); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(boxed._1)); + let n: rt.u32 = data.length as rt.u32; + const both: [rt.u32, rt.u32] = [n, n]; + n = 9; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n))); + const word: Uint8Array = Uint8Array.of(0, 0, 0, data.length & 0xff); + const converted: rt.u32 = rt.u32FromBeBytes(word); + word[0] = 9; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32))); + const cell: Uint8Array = Uint8Array.of(data.length & 0xff); + rt.byteVecPush(out, writeThenRead(rt.copy(cell), cell)); + const source: Uint8Array = Uint8Array.of(data.length & 0xff); + const returned: Uint8Array = same(rt.copy(source)); + source[0] = 9; + const _145: rt.u8 = returned[0]; + rt.byteVecExtendFromSlice(out, Uint8Array.of(_145, source[0])); + rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); + const marked: boolean = mark(out, 1) === 0; + mark(out, 2); + rt.byteVecPush(out, marked ? 1 : 0); + let opt: Meters.Meters | undefined = rt.copy({ _0: 9 }); + const taken2 = opt; + opt = undefined; + const taken: Meters.Meters | undefined = taken2; + rt.byteVecPush(out, opt === undefined ? 1 : 0); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(taken, 0, (m: Meters.Meters): rt.u64 => { + return m._0; + }))); + const res: rt.Result = rt.Ok(p); + const first: Point.Point = rt.copy(rt.resultUnwrap(res, rt.u8Display)); + first.x = 2; + const fail: rt.Result = rt.Err(rt.copy(q)); + const err: Point.Point = rt.copy(rt.resultUnwrapErr(fail, rt.u8Display)); + err.y = 3; + rt.byteVecExtendFromSlice(out, Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Display).y & 0xff)); } /** `a`'s byte, after writing `b`'s. */ @@ -243,22 +243,19 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { const _70: rt.usize = mark(out, 12); let iterStart: rt.usize = rt.usizeSub(mark(out, 13), 4); const iterEnd: rt.usize = _70; - while (true) { - if (!((_75 = iterStart++) < iterEnd)) { - const len: rt.usize = data.length; - const _83: Uint8Array = logged(data, out); - const _85: rt.usize = rt.min(mark(out, 14), len); - const _87: rt.usize = rt.usizeDiv(rt.min(mark(out, 15), len), 2); - const _82: Uint8Array = rt.sliceRange(_83, _87, _85); - const _102: Shape.Shape = taken; - const _103: rt.usize = sum; - const args2: rt.Fmt[] = [(f: rt.Formatter) => Shape.fmt$Debug(rect, f), (f: rt.Formatter) => Shape.fmt$Debug(line, f), (f: rt.Formatter) => Pair.fmt$Debug(pair, f), (f: rt.Formatter) => Point.fmt$Debug(read, f), (f: rt.Formatter) => Moved.fmt$Debug(updated, f), (f: rt.Formatter) => Shape.fmt$Debug(_102, f), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.usizeDisplay(_63, f), (f: rt.Formatter) => rt.usizeDisplay(_103, f), (f: rt.Formatter) => rt.fmtList(_82, f, rt.u8Display)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]))); - indexed(data, out); - return; - } + while ((_75 = iterStart++) < iterEnd) { sum = rt.usizeAdd(sum, _75); } + const len: rt.usize = data.length; + const _83: Uint8Array = logged(data, out); + const _85: rt.usize = rt.min(mark(out, 14), len); + const _87: rt.usize = rt.usizeDiv(rt.min(mark(out, 15), len), 2); + const _82: Uint8Array = rt.sliceRange(_83, _87, _85); + const _102: Shape.Shape = taken; + const _103: rt.usize = sum; + const args2: rt.Fmt[] = [(f: rt.Formatter) => Shape.fmt$Debug(rect, f), (f: rt.Formatter) => Shape.fmt$Debug(line, f), (f: rt.Formatter) => Pair.fmt$Debug(pair, f), (f: rt.Formatter) => Point.fmt$Debug(read, f), (f: rt.Formatter) => Moved.fmt$Debug(updated, f), (f: rt.Formatter) => Shape.fmt$Debug(_102, f), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.usizeDisplay(_63, f), (f: rt.Formatter) => rt.usizeDisplay(_103, f), (f: rt.Formatter) => rt.fmtList(_82, f, rt.u8Display)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]))); + indexed(data, out); } /** @@ -351,7 +348,7 @@ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_5 === rt.DONE) { - return; + break; } const b: rt.u8 = _5; const _10: rt.u8 = rt.u8Rem(b, 3); @@ -404,127 +401,116 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { }; const stack: rt.ByteVec = rt.sliceToByteVec(data); let popped: rt.u32 = 0; - l0: while (true) { + while (true) { const _5: rt.u8 | undefined = rt.byteVecPop(stack); if (_5 !== undefined) { const top: rt.u8 = _5; if (!(top === 0)) { popped = rt.u32Add(popped, top as rt.u32); - if (!(popped > 1000)) { - continue l0; + if (popped > 1000) { + break; } - } else { - continue l0; } + } else { + break; } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(popped)); - let found: [rt.usize, rt.usize] | undefined = undefined; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = data.length; - l2: while (true) { - b3: { - if ((_24 = iterStart++) < iterEnd) { - const i: rt.usize = _24; - let iterStart2: rt.usize = rt.usizeAdd(i, 1); - const iterEnd2: rt.usize = data.length; - while (true) { - if (!((_34 = iterStart2++) < iterEnd2)) { - continue l2; - } - const j: rt.usize = _34; - rt.idx(data, i); - const _39: rt.u8 = data[i]; - rt.idx(data, j); - if (!(_39 === data[j])) { - rt.idx(data, j); - if (data[j] === 0) { - continue l2; - } - } else { - found = [i, j] as [rt.usize, rt.usize]; - break b3; - } - } + } + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(popped)); + let found: [rt.usize, rt.usize] | undefined = undefined; + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = data.length; + l3: while ((_24 = iterStart++) < iterEnd) { + const i: rt.usize = _24; + let iterStart2: rt.usize = rt.usizeAdd(i, 1); + const iterEnd2: rt.usize = data.length; + while (true) { + if (!((_34 = iterStart2++) < iterEnd2)) { + continue l3; + } + const j: rt.usize = _34; + rt.idx(data, i); + const _39: rt.u8 = data[i]; + rt.idx(data, j); + if (!(_39 === data[j])) { + rt.idx(data, j); + if (data[j] === 0) { + continue l3; } + } else { + found = [i, j] as [rt.usize, rt.usize]; + break l3; } - if (found === undefined) { - rt.byteVecPush(out, 255); + } + } + if (found === undefined) { + rt.byteVecPush(out, 255); + } else { + const i2: rt.usize = found[0]; + const j2: rt.usize = found[1]; + rt.byteVecExtendFromSlice(out, Uint8Array.of(i2 & 0xff, j2 & 0xff)); + } + let n: rt.u64 = data.length as rt.u64; + b6: { + while (!rt.u64Le(n, 1)) { + if (!(rt.u64Rem(n, 2) === 0)) { + _65 = rt.u64Add(rt.u64Mul(3, n), 1); } else { - const i2: rt.usize = found[0]; - const j2: rt.usize = found[1]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(i2 & 0xff, j2 & 0xff)); + _65 = rt.u64Div(n, 2); } - let n: rt.u64 = data.length as rt.u64; - l6: while (true) { - if (!rt.u64Le(n, 1)) { - if (!(rt.u64Rem(n, 2) === 0)) { - _65 = rt.u64Add(rt.u64Mul(3, n), 1); - } else { - _65 = rt.u64Div(n, 2); - } - n = _65; - if (!rt.u64Gt(n, 100)) { - continue l6; - } - steps = 1; - } else { - steps = 0; - } - rt.byteVecPush(out, steps); - let count: rt.u8 = 0; - const iter3: rt.RangeInclusive = new rt.RangeInclusive(0, 3, rt.u8Step); - while (true) { - const _84: rt.u8 | rt.Done = iter3.next(); - if (_84 === rt.DONE) { - let i3: rt.i8 = 10; - while (true) { - if (!(i3 > -3)) { - rt.byteVecPush(out, count); - const lo: rt.i32 = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); - const r: rt.Range = new rt.Range(lo, rt.i32Add(lo, 3)); - const first: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; - r.end = r.start; - const second: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; - if (first !== undefined) { - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(first)); - } - if (second !== undefined) { - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(second)); - } - let iterStart3: rt.i32 = lo; - const iterEnd3: rt.i32 = 2; - while (true) { - if (!((_124 = iterStart3++) < iterEnd3)) { - let iterStart4: rt.i8 = rt.i8Sub(124, (lo << 24) >> 24); - const iterEnd4: rt.i8 = 127; - while (true) { - if (!((_136 = iterStart4++) < iterEnd4)) { - rt.byteVecPush(out, firstRepeat(data)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(tailBreak(data))); - rt.byteVecPush(out, armLoop(data)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(position$u8(data, 0) as rt.u32)); - rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); - drain(data, out); - rt.byteVecPush(out, returnedLoop(data)); - branchLoops(data, out); - diverging(data, out); - return; - } - rt.byteVecPush(out, _136 & 0xff); - } - } - rt.byteVecPush(out, _124 & 0xff); - } - } - i3 = rt.i8Sub(i3, 4); - count = rt.u8Add(count, 1); - } - } - count = rt.u8Add(count, 1); - } + n = _65; + if (rt.u64Gt(n, 100)) { + steps = 1; + break b6; } } + steps = 0; } + rt.byteVecPush(out, steps); + let count: rt.u8 = 0; + const iter3: rt.RangeInclusive = new rt.RangeInclusive(0, 3, rt.u8Step); + while (true) { + const _84: rt.u8 | rt.Done = iter3.next(); + if (_84 === rt.DONE) { + break; + } + count = rt.u8Add(count, 1); + } + let i3: rt.i8 = 10; + while (i3 > -3) { + i3 = rt.i8Sub(i3, 4); + count = rt.u8Add(count, 1); + } + rt.byteVecPush(out, count); + const lo: rt.i32 = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); + const r: rt.Range = new rt.Range(lo, rt.i32Add(lo, 3)); + const first: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; + r.end = r.start; + const second: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; + if (first !== undefined) { + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(first)); + } + if (second !== undefined) { + rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(second)); + } + let iterStart3: rt.i32 = lo; + const iterEnd3: rt.i32 = 2; + while ((_124 = iterStart3++) < iterEnd3) { + rt.byteVecPush(out, _124 & 0xff); + } + let iterStart4: rt.i8 = rt.i8Sub(124, (lo << 24) >> 24); + const iterEnd4: rt.i8 = 127; + while ((_136 = iterStart4++) < iterEnd4) { + rt.byteVecPush(out, _136 & 0xff); + } + rt.byteVecPush(out, firstRepeat(data)); + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(tailBreak(data))); + rt.byteVecPush(out, armLoop(data)); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(position$u8(data, 0) as rt.u32)); + rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); + drain(data, out); + rt.byteVecPush(out, returnedLoop(data)); + branchLoops(data, out); + diverging(data, out); } /** @@ -680,33 +666,27 @@ export function guardedReturn(data: Uint8Array): rt.u8 { /** A loop ending the function, left by `break` with values that never exist. */ export function brokenNever(data: Uint8Array): rt.u8 { - let _0!: rt.u8; let i: rt.usize = 0; - l0: while (true) { - if (!(i >= data.length)) { - const _6: rt.usize = i; - rt.idx(data, _6); - const value = data[_6]; - if (value === 251) { - const arg = ([i] as [rt.usize])[0]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; - rt.panicFmt(["broken at ", args2[0]]); - return _0; - } - if (value === 252) { - const _19: rt.usize = i; - rt.idx(data, _19); - bail(data[_19]); - return _0; - } + while (!(i >= data.length)) { + const _6: rt.usize = i; + rt.idx(data, _6); + const value = data[_6]; + if (value === 251) { + const arg = ([i] as [rt.usize])[0]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + rt.panicFmt(["broken at ", args2[0]]); + } else if (value === 252) { + const _19: rt.usize = i; + rt.idx(data, _19); + bail(data[_19]); + } else { if (value === 0) { return i & 0xff; } i = rt.usizeAdd(i, 1); - continue l0; } - return 204; } + return 204; } /** @@ -714,57 +694,50 @@ export function brokenNever(data: Uint8Array): rt.u8 { * only `return` leaves gives the function's result. */ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { - let _0!: rt.u8; let i: rt.usize = 0; - l0: while (true) { - if (!(i >= data.length)) { - const _8: rt.usize = i; - rt.idx(data, _8); - const value = data[_8]; - if (value === 239) { - const arg = ([i] as [rt.usize])[0]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; - rt.panicFmt(["bound at ", args2[0]]); - return _0; - } - if (value === 240) { - const _22: rt.usize = i; - rt.idx(data, _22); - bail(data[_22]); - return _0; - } + while (!(i >= data.length)) { + const _8: rt.usize = i; + rt.idx(data, _8); + const value = data[_8]; + if (value === 239) { + const arg = ([i] as [rt.usize])[0]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; + rt.panicFmt(["bound at ", args2[0]]); + } else if (value === 240) { + const _22: rt.usize = i; + rt.idx(data, _22); + bail(data[_22]); + } else { if (value === 0) { return i & 0xff; } if (value === 128) { - l2: while (true) { + while (true) { i = rt.usizeAdd(i, 1); if (!(i >= data.length)) { const _32: rt.usize = i; rt.idx(data, _32); - if (!(data[_32] < 128)) { - continue l2; + if (data[_32] < 128) { + break; } + } else { + break; } - return i & 0xff; } + return i & 0xff; } i = rt.usizeAdd(i, 1); - continue l0; } - return 187; } + return 187; } /** Loops that `break` ending a guarded `match` arm and an `if let` chain branch. */ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { let i: rt.usize = 0; - l0: while (true) { - if (!(rt.usizeAdd(i, 1) < data.length)) { - return; - } + l1: while (rt.usizeAdd(i, 1) < data.length) { const w: Uint8Array = rt.sliceRange(data, i, rt.usizeAdd(i, 2)); - b1: { + b2: { i = rt.usizeAdd(i, 2); if (w.length === 2) { const a: rt.u8 = w[0]; @@ -776,7 +749,7 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { n = rt.u8Sub(n, 1); rt.byteVecPush(out, n); } else { - break b1; + break b2; } } } @@ -792,7 +765,7 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { n2 = rt.u8Div(n2, 2); rt.byteVecPush(out, n2); if (n2 < 4) { - continue l0; + continue l1; } } } @@ -804,69 +777,63 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { /** A loop that only `return` leaves, returned itself, around loops that `break`. */ export function returnedLoop(data: Uint8Array): rt.u8 { let i: rt.usize = 0; - l0: while (true) { - if (!(i >= data.length)) { - const iterS: Uint8Array = rt.sliceRange(data, i); - let iterI: number = 0; - l2: while (true) { - const _11: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_11 !== rt.DONE) { - const b: rt.u8 = _11; - if (!(b === 0)) { - if (!(b > 240)) { - continue l2; - } - return b ^ (i & 0xff); - } + while (!(i >= data.length)) { + const iterS: Uint8Array = rt.sliceRange(data, i); + let iterI: number = 0; + while (true) { + const _11: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_11 === rt.DONE) { + break; + } + const b: rt.u8 = _11; + if (!(b === 0)) { + if (b > 240) { + return b ^ (i & 0xff); } - i = rt.usizeAdd(i, 1); - continue l0; + } else { + break; } } - return 221; + i = rt.usizeAdd(i, 1); } + return 221; } /** A loop that ends the function, left only by `return` from nested scopes. */ export function firstRepeat(data: Uint8Array): rt.u8 { let i: rt.usize = 0; - l0: while (true) { - if (!(i >= data.length)) { - let j: rt.usize = rt.usizeAdd(i, 1); - while (true) { - if (!(j < data.length)) { - i = rt.usizeAdd(i, 1); - continue l0; - } - const _14: rt.usize = j; - rt.idx(data, _14); - if (!(data[_14] === 0)) { - const _21: rt.usize = i; - rt.idx(data, _21); - const _20: rt.u8 = data[_21]; - const _25: rt.usize = j; - rt.idx(data, _25); - if (!(_20 === data[_25])) { - j = rt.usizeAdd(j, 1); - } else { - const _29: rt.usize = j; - rt.idx(data, _29); - return data[_29] ^ (i & 0xff); - } + l2: while (!(i >= data.length)) { + let j: rt.usize = rt.usizeAdd(i, 1); + while (j < data.length) { + const _14: rt.usize = j; + rt.idx(data, _14); + if (!(data[_14] === 0)) { + const _21: rt.usize = i; + rt.idx(data, _21); + const _20: rt.u8 = data[_21]; + const _25: rt.usize = j; + rt.idx(data, _25); + if (!(_20 === data[_25])) { + j = rt.usizeAdd(j, 1); } else { - i = rt.usizeAdd(j, 1); - continue l0; + const _29: rt.usize = j; + rt.idx(data, _29); + return data[_29] ^ (i & 0xff); } + } else { + i = rt.usizeAdd(j, 1); + continue l2; } } - return 255; + i = rt.usizeAdd(i, 1); } + return 255; } /** A loop that ends the function, left by `break` with a value from nested scopes. */ export function tailBreak(data: Uint8Array): rt.u16 { let i: rt.usize = 0; - l0: while (true) { + l2: while (true) { if (!(i >= data.length)) { const _7: rt.usize = i; rt.idx(data, _7); @@ -874,7 +841,7 @@ export function tailBreak(data: Uint8Array): rt.u16 { i = rt.usizeAdd(i, 1); const _11: rt.u8 = rt.u8Rem(b, 4); if (_11 === 0) { - continue l0; + continue; } if (_11 === 1) { const iterS: Uint8Array = rt.sliceRange(data, i); @@ -882,7 +849,7 @@ export function tailBreak(data: Uint8Array): rt.u16 { while (true) { const _18: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_18 === rt.DONE) { - continue l0; + continue l2; } const c: rt.u8 = _18; if (c === b) { @@ -903,12 +870,13 @@ export function tailBreak(data: Uint8Array): rt.u16 { return 7; } } else { - continue l0; + continue l2; } } } - return 256; + break; } + return 256; } /** A loop that only `return` leaves, in a `match` arm that needs a value. */ @@ -920,52 +888,46 @@ export function armLoop(data: Uint8Array): rt.u8 { return rt.u8Div(_3, 2); } } - while (true) { - if (!(k >= data.length)) { - const _13: rt.usize = k; - rt.idx(data, _13); - if (!(data[_13] >= 128)) { - k = rt.usizeAdd(k, 1); - } else { - const _17: rt.usize = k; - rt.idx(data, _17); - return rt.u8Sub(data[_17], 128); - } + while (!(k >= data.length)) { + const _13: rt.usize = k; + rt.idx(data, _13); + if (!(data[_13] >= 128)) { + k = rt.usizeAdd(k, 1); } else { - return 238; + const _17: rt.usize = k; + rt.idx(data, _17); + return rt.u8Sub(data[_17], 128); } } + return 238; } /** A generic function ending in a loop. */ export function position$u8(items: Uint8Array, want: rt.u8): rt.usize { let i: rt.usize = 0; - l0: while (true) { + while (true) { if (!(i === items.length)) { const _9: rt.usize = i; rt.idx(items, _9); if (!((items[_9] === want))) { i = rt.usizeAdd(i, 1); - continue l0; + } else { + return i; } + } else { return i; } - return i; } } /** A unit function ending in a loop. */ export function drain(data: Uint8Array, out: rt.ByteVec): void { let i: rt.usize = 0; - while (true) { - if (!(i >= data.length)) { - const _10: rt.usize = i; - rt.idx(data, _10); - rt.byteVecPush(out, data[_10] ^ 90); - i = rt.usizeAdd(i, 2); - } else { - return; - } + while (!(i >= data.length)) { + const _10: rt.usize = i; + rt.idx(data, _10); + rt.byteVecPush(out, data[_10] ^ 90); + i = rt.usizeAdd(i, 2); } } @@ -996,70 +958,9 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _33: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_33 === rt.DONE) { - b5: { - if (data.length >= 2) { - const _56: Dir.Dir | undefined = dir(data[0]); - if (_56 !== undefined) { - const d: Dir.Dir = _56; - if (data[1] > 10) { - rt.byteVecPush(out, from$From_Dir_u8(d)); - break b5; - } - } - } - rt.byteVecPush(out, 238); - } - const shape_: Shape.Shape = shape(data); - b7: { - if (shape_.tag !== "Dot") { - if (shape_.tag === "Line") { - const a: Point.Point = shape_._0; - const b2: Point.Point = shape_._1; - area = rt.i64Mul(rt.i32Sub(a.x, b2.x) as rt.i64, rt.i32Sub(a.y, b2.y) as rt.i64); - break b7; - } - if (shape_.width !== 0) { - if (!(shape_.corner.x > 0)) { - const width2: rt.u16 = shape_.width; - const height: rt.u16 = shape_.height; - area = rt.i64Neg(rt.i64Mul(width2 as rt.i64, height as rt.i64)); - break b7; - } - const x: rt.i32 = shape_.corner.x; - const _74: rt.i64 = shape_.width as rt.i64; - area = rt.i64Mul(_74, x as rt.i64); - break b7; - } - } - area = 0; - } - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); - if (!(rt.usizeRem(data.length, 2) === 0)) { - either = rt.Err(160); - } else { - either = rt.Ok(data.length & 0xff); - } - if (either.ok) { - v = either.value; - } else { - v = either.error; - } - rt.byteVecPush(out, v); - rt.byteVecPush(out, rt.u8Add(Uint8Array.of().length & 0xff, rt.iterSum(rt.iterSlice(Uint8Array.of()), rt.u8Add, 0))); - const bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); - bytes.subarray(1, 3)[0] = 9; - rt.byteVecExtendFromSlice(out, bytes); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out)))); - const parsed: rt.Result = rt.Ok(data.length & 0xff); - const a2: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; - const b3: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; - rt.byteVecExtendFromSlice(out, Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2))); - const arg = ([parsed] as [rt.Result])[0]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); - return; + break; } - b2: { + b3: { const b: rt.u8 = _33; if (b === 0) { class_ = 0; @@ -1069,14 +970,14 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { if (1 <= b) { if (b <= 9) { class_ = 1; - break b2; + break b3; } } if (100 <= b) { if (b < 200) { if (rt.u8Rem(b, 2) === 0) { class_ = 3; - break b2; + break b3; } } } @@ -1089,6 +990,67 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, class_); } + b6: { + if (data.length >= 2) { + const _56: Dir.Dir | undefined = dir(data[0]); + if (_56 !== undefined) { + const d: Dir.Dir = _56; + if (data[1] > 10) { + rt.byteVecPush(out, from$From_Dir_u8(d)); + break b6; + } + } + } + rt.byteVecPush(out, 238); + } + const shape_: Shape.Shape = shape(data); + b8: { + if (shape_.tag !== "Dot") { + if (shape_.tag === "Line") { + const a: Point.Point = shape_._0; + const b2: Point.Point = shape_._1; + area = rt.i64Mul(rt.i32Sub(a.x, b2.x) as rt.i64, rt.i32Sub(a.y, b2.y) as rt.i64); + break b8; + } + if (shape_.width !== 0) { + if (!(shape_.corner.x > 0)) { + const width2: rt.u16 = shape_.width; + const height: rt.u16 = shape_.height; + area = rt.i64Neg(rt.i64Mul(width2 as rt.i64, height as rt.i64)); + break b8; + } + const x: rt.i32 = shape_.corner.x; + const _74: rt.i64 = shape_.width as rt.i64; + area = rt.i64Mul(_74, x as rt.i64); + break b8; + } + } + area = 0; + } + rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); + if (!(rt.usizeRem(data.length, 2) === 0)) { + either = rt.Err(160); + } else { + either = rt.Ok(data.length & 0xff); + } + if (either.ok) { + v = either.value; + } else { + v = either.error; + } + rt.byteVecPush(out, v); + rt.byteVecPush(out, rt.u8Add(Uint8Array.of().length & 0xff, rt.iterSum(rt.iterSlice(Uint8Array.of()), rt.u8Add, 0))); + const bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); + bytes.subarray(1, 3)[0] = 9; + rt.byteVecExtendFromSlice(out, bytes); + rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: rt.u64Of(18446744073709551615n) }], out)))); + const parsed: rt.Result = rt.Ok(data.length & 0xff); + const a2: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; + const b3: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; + rt.byteVecExtendFromSlice(out, Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2))); + const arg = ([parsed] as [rt.Result])[0]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); } /** A `match` without arms on a scrutinee that diverges, not on an empty type. */ @@ -1107,46 +1069,48 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _8: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_8 === rt.DONE) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); - const base: rt.u32 = data.length as rt.u32; - const captured = base; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { - return rt.u32Add(rt.u32Mul(v2, 3), captured); - }, sum))); - let n: rt.u32 = base; - const captured2 = n; - n = rt.u32Add(n, 10); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(((): rt.u32 => { - return rt.u32Add(captured2, 1); - })(), n))); - const whole: Uint8Array = Uint8Array.of(data.length & 0xff); - overwrite(whole); - rt.byteVecPush(out, whole[0]); - const parsed: Array = []; - const iterS2: Uint8Array = data; - let iterI2: number = 0; - while (true) { - const _53: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_53 === rt.DONE) { - const tags: rt.ByteVec = new rt.ByteVec(); - const iterS3: Array = parsed; - let iterI3: number = 0; - while (true) { - const _64: Dir.Dir | undefined | rt.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; - if (_64 === rt.DONE) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); - return; - } - const _70: rt.u8 = rt.optionUnwrapOr(rt.optionMap(_64, from$From_Dir_u8), 0); - rt.byteVecPush(tags, _70); - } - } - const _59: Dir.Dir | undefined = dir(_53); - parsed.push(_59); - } + break; } add(_8); } + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); + const base: rt.u32 = data.length as rt.u32; + const captured = base; + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { + return rt.u32Add(rt.u32Mul(v2, 3), captured); + }, sum))); + let n: rt.u32 = base; + const captured2 = n; + n = rt.u32Add(n, 10); + rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(((): rt.u32 => { + return rt.u32Add(captured2, 1); + })(), n))); + const whole: Uint8Array = Uint8Array.of(data.length & 0xff); + overwrite(whole); + rt.byteVecPush(out, whole[0]); + const parsed: Array = []; + const iterS2: Uint8Array = data; + let iterI2: number = 0; + while (true) { + const _53: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_53 === rt.DONE) { + break; + } + const _59: Dir.Dir | undefined = dir(_53); + parsed.push(_59); + } + const tags: rt.ByteVec = new rt.ByteVec(); + const iterS3: Array = parsed; + let iterI3: number = 0; + while (true) { + const _64: Dir.Dir | undefined | rt.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; + if (_64 === rt.DONE) { + break; + } + const _70: rt.u8 = rt.optionUnwrapOr(rt.optionMap(_64, from$From_Dir_u8), 0); + rt.byteVecPush(tags, _70); + } + rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); } /** Replaces `a` whole from a closure. */ @@ -1277,71 +1241,7 @@ export function flows(data: Uint8Array, out: rt.ByteVec): void { while (true) { const _7: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_7 === rt.DONE) { - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(total)); - const a: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - if (rt.u8Rem(a, 3) === 0) { - result = rt.Err(a); - } else { - result = rt.Ok(rt.u16Add(a as rt.u16, 256)); - } - rt.byteVecPush(out, result.ok ? 1 : 0); - if (result.ok) { - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(result.value)); - } else { - rt.byteVecPush(out, (result as { ok: false; error: rt.u8 }).error); - } - if (rt.u8Rem(a, 5) === 0) { - option = undefined; - } else { - option = rt.u8Div(a, 5); - } - rt.byteVecPush(out, option === undefined ? 1 : 0); - if (option !== undefined) { - rt.byteVecPush(out, option); - } else { - rt.byteVecPush(out, 253); - } - const original: rt.Result = rt.Ok(Uint8Array.of(a, 1)); - const copied: rt.Result = rt.copy(original); - if (copied.ok) { - const _83: rt.u8 = rt.u8WrappingAdd(copied.value[0], 1); - copied.value[0] = _83; - } - const iter2: rt.Iter> = rt.iterSlice([original, rt.copy(copied)]); - while (true) { - const _93: rt.Result | rt.Done = iter2.next(); - if (_93 === rt.DONE) { - const slot: rt.Mutex = new rt.Mutex(undefined); - const iterS2: Uint8Array = data; - let iterI2: number = 0; - while (true) { - const _106: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_106 === rt.DONE) { - rt.byteVecPush(out, rt.optionUnwrapOr(slot.value, 252)); - return; - } - const x2: rt.u8 = _106; - const held: rt.Mutex = slot; - const _114: rt.u8 | undefined = held.value; - b9: { - if (_114 !== undefined) { - if (_114 >= x2) { - _113 = true; - break b9; - } - } - _113 = false; - } - if (!_113) { - held.value = x2; - } - } - } - const flow3: rt.Result = _93; - if (flow3.ok) { - rt.byteVecExtendFromSlice(out, flow3.value); - } - } + break; } const x: rt.u8 = _7; const flow: rt.Result = step(total, x); @@ -1364,6 +1264,72 @@ export function flows(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, 0); } } + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(total)); + const a: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + if (rt.u8Rem(a, 3) === 0) { + result = rt.Err(a); + } else { + result = rt.Ok(rt.u16Add(a as rt.u16, 256)); + } + rt.byteVecPush(out, result.ok ? 1 : 0); + if (result.ok) { + rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(result.value)); + } else { + rt.byteVecPush(out, (result as { ok: false; error: rt.u8 }).error); + } + if (rt.u8Rem(a, 5) === 0) { + option = undefined; + } else { + option = rt.u8Div(a, 5); + } + rt.byteVecPush(out, option === undefined ? 1 : 0); + if (option !== undefined) { + rt.byteVecPush(out, option); + } else { + rt.byteVecPush(out, 253); + } + const original: rt.Result = rt.Ok(Uint8Array.of(a, 1)); + const copied: rt.Result = rt.copy(original); + if (copied.ok) { + const _83: rt.u8 = rt.u8WrappingAdd(copied.value[0], 1); + copied.value[0] = _83; + } + const iter2: rt.Iter> = rt.iterSlice([original, rt.copy(copied)]); + while (true) { + const _93: rt.Result | rt.Done = iter2.next(); + if (_93 === rt.DONE) { + break; + } + const flow3: rt.Result = _93; + if (flow3.ok) { + rt.byteVecExtendFromSlice(out, flow3.value); + } + } + const slot: rt.Mutex = new rt.Mutex(undefined); + const iterS2: Uint8Array = data; + let iterI2: number = 0; + while (true) { + const _106: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_106 === rt.DONE) { + break; + } + const x2: rt.u8 = _106; + const held: rt.Mutex = slot; + const _114: rt.u8 | undefined = held.value; + b12: { + if (_114 !== undefined) { + if (_114 >= x2) { + _113 = true; + break b12; + } + } + _113 = false; + } + if (!_113) { + held.value = x2; + } + } + rt.byteVecPush(out, rt.optionUnwrapOr(slot.value, 252)); } //# sourceMappingURL=shapes.ts.map diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index 07264c8ef..85ff1edb9 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -18,59 +18,52 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { const weak: rt.Weak = new rt.Weak(waiter.shared); const iterS: rt.Weak[] = self.entries; let iterI: number = 0; - l0: while (true) { - const _8: rt.Weak | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - b1: { - b2: { - if (_8 === rt.DONE) { - let probes: rt.usize = rt.min(self.entries.length, 2); - while (true) { - if (!(probes > 0)) { - b4: { - if (self.entries.length >= 4) { - const live: rt.Weak[] = []; - const taken = self.entries; - self.entries = []; - const iterS2: rt.Weak[] = taken; - let iterI2: number = 0; - while (true) { - const _43: rt.Weak | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_43 === rt.DONE) { - const _53: rt.Weak[] = live; - self.entries = _53; - self.cursor = 0; - break b4; - } - const entry: rt.Weak = _43; - if (entry.arc.strong > 0) { - live.push(entry); - } - } - } - } - self.entries.push(weak); - break b1; - } - const _23: rt.usize = self.cursor; - const at = rt.idx(self.entries, _23); - if (!(self.entries[at].arc.strong === 0)) { - self.cursor = rt.usizeRem(rt.usizeAdd(self.cursor, 1), self.entries.length); - probes = rt.usizeSub(probes, 1); - } else { - const _24: rt.Weak = weak; - const _27: rt.usize = self.cursor; - const at2 = rt.idx(self.entries, _27); - self.entries[at2] = _24; - break b2; - } - } + b1: { + while (true) { + const _8: rt.Weak | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_8 === rt.DONE) { + break; + } + if (_8.arc === weak.arc) { + break b1; + } + } + let probes: rt.usize = rt.min(self.entries.length, 2); + while (probes > 0) { + const _23: rt.usize = self.cursor; + const at = rt.idx(self.entries, _23); + if (!(self.entries[at].arc.strong === 0)) { + self.cursor = rt.usizeRem(rt.usizeAdd(self.cursor, 1), self.entries.length); + probes = rt.usizeSub(probes, 1); + } else { + const _24: rt.Weak = weak; + const _27: rt.usize = self.cursor; + const at2 = rt.idx(self.entries, _27); + self.entries[at2] = _24; + break b1; + } + } + if (self.entries.length >= 4) { + const live: rt.Weak[] = []; + const taken = self.entries; + self.entries = []; + const iterS2: rt.Weak[] = taken; + let iterI2: number = 0; + while (true) { + const _43: rt.Weak | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; + if (_43 === rt.DONE) { + break; } - if (!((_8.arc === weak.arc))) { - continue l0; + const entry: rt.Weak = _43; + if (entry.arc.strong > 0) { + live.push(entry); } } + const _53: rt.Weak[] = live; + self.entries = _53; + self.cursor = 0; } - return; + self.entries.push(weak); } } @@ -95,7 +88,7 @@ export function wake(self: WaiterList): void { while (true) { const _6: rt.Weak | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; if (_6 === rt.DONE) { - return; + break; } const _10: rt.Arc | undefined = rt.weakUpgrade(_6); if (_10 !== undefined) { diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index fd5775046..32a4f139c 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -80,7 +80,7 @@ export class sumFuture { let unwind: number = 0; try { let bb0: number = 0; - l0: while (true) { + while (true) { switch (bb0) { case 0: if (this.#state === 0) { @@ -90,7 +90,7 @@ export class sumFuture { this.#inner = Guard.new(rt.u32Add(this.#guard$2.id, 100), Log.clone$Clone(this.#guard$2.log)); this.#total = 0; bb0 = 4; - continue l0; + continue; } if (this.#state === 1) { rt.asyncFnResumed(); @@ -98,13 +98,13 @@ export class sumFuture { rt.asyncFnResumedPanic(); } else { bb0 = 7; - continue l0; + continue; } case 4: unwind = 32; this.#awaitee = new recvFuture(this.#rx$2); bb0 = 7; - continue l0; + continue; case 7: unwind = 31; const _11: rt.Poll = this.#awaitee.poll(_2); @@ -125,7 +125,7 @@ export class sumFuture { Log.note(this.#inner.log, _32); this.#total = rt.u64Add(this.#total, value); bb0 = 4; - continue l0; + continue; } } else { unwind = 33; @@ -1186,56 +1186,56 @@ export function temporaries(log: Log.Log, id: rt.u32): void { unwind = 75; const _126: rt.u32 | rt.Done = Countdown.next$Iterator(iter); if (_126 === rt.DONE) { - unwind = 76; - rt.drop(iter); - const arg6 = ([sum_] as [rt.u32])[0]; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg6, f)]; - Log.note(log, rt.fmtFormat(["counted ", args12[0]])); - unwind = 77; - rt.dropAll(rest); - unwind = 0; - rt.drop(head); - return; + break; } sum_ = rt.u32Add(sum_, _126); } + unwind = 76; + rt.drop(iter); + const arg6 = ([sum_] as [rt.u32])[0]; + const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg6, f)]; + Log.note(log, rt.fmtFormat(["counted ", args12[0]])); + unwind = 77; + rt.dropAll(rest); + unwind = 0; + rt.drop(head); } catch (e) { - b3: { - b4: { - b5: { + b4: { + b5: { + b6: { if (unwind === 0) { throw e; } if (unwind === 75) { rt.drop(iter); - break b5; + break b6; } if (unwind === 76) { - break b5; + break b6; } if (unwind === 77) { - break b4; + break b5; } if (unwind === 78) { rt.drop(_73); } else if (unwind !== 79) { if (unwind === 80) { rt.drop(_57); - break b3; + break b4; } if (unwind === 81) { rt.drop(_39); - break b3; + break b4; } if (unwind === 82) { rt.drop(_24); - break b3; + break b4; } rt.drop(_11); - break b3; + break b4; } rt.drop(_70); - break b3; + break b4; } rt.dropAll(rest); } @@ -1378,28 +1378,26 @@ export function turns(log: Log.Log, count: rt.u32): void { if (!(_179 < 2)) { rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _179); } - b3: { - if (count === 0) { - Log.note(log, rt.fmtFormat(["no turns"])); - } else if (!(count < 4)) { - Log.note(log, rt.fmtFormat(["many turns"])); - } else { - let left: rt.u32 = count; - while (true) { - turn = Guard.new(left, Log.clone$Clone(log)); - if (!(left === 1)) { - unwind = 142; - Guard.note(turn, "turn"); - const _199: rt.u32 = rt.u32Sub(left, 1); - unwind = 143; - left = _199; - rt.drop(turn); - } else { - rt.drop(turn); - break b3; - } + if (count === 0) { + Log.note(log, rt.fmtFormat(["no turns"])); + } else if (!(count < 4)) { + Log.note(log, rt.fmtFormat(["many turns"])); + } else { + let left: rt.u32 = count; + while (true) { + turn = Guard.new(left, Log.clone$Clone(log)); + if (!(left === 1)) { + unwind = 142; + Guard.note(turn, "turn"); + const _199: rt.u32 = rt.u32Sub(left, 1); + unwind = 143; + left = _199; + rt.drop(turn); + } else { + break; } } + rt.drop(turn); } unwind = 145; rt.dropAll(spares); @@ -1422,16 +1420,16 @@ export function turns(log: Log.Log, count: rt.u32): void { unwind = 0; rt.dropAll(pair.slice(1, 2)); } catch (e) { - b5: { - b6: { - b7: { - b8: { - b9: { - b10: { - b11: { - b12: { - b13: { - b14: { + b6: { + b7: { + b8: { + b9: { + b10: { + b11: { + b12: { + b13: { + b14: { + b15: { if (unwind === 0) { throw e; } @@ -1440,41 +1438,41 @@ export function turns(log: Log.Log, count: rt.u32): void { } else if (unwind !== 143) { if (unwind === 144) { rt.drop(_171); - break b14; + break b15; } if (unwind === 145) { - break b14; + break b15; } if (unwind === 146) { - break b13; + break b14; } if (unwind === 147) { - break b12; + break b13; } if (unwind === 148) { rt.drop(_112); - break b11; + break b12; } if (unwind === 149) { - break b11; + break b12; } if (unwind === 150) { - break b10; + break b11; } if (unwind === 151) { - break b9; + break b10; } if (unwind === 152) { - break b8; + break b9; } if (unwind === 153) { - break b7; + break b8; } if (unwind === 154) { rt.drop(_4); - break b5; + break b6; } - break b6; + break b7; } rt.dropAll(spares); } @@ -1559,7 +1557,7 @@ export class drainFuture { let unwind: number = 0; try { let bb0: number = 0; - l0: while (true) { + while (true) { switch (bb0) { case 0: if (this.#state === 0) { @@ -1567,7 +1565,7 @@ export class drainFuture { this.#depth$2 = this.#depth; this.#total = 0; bb0 = 1; - continue l0; + continue; } if (this.#state === 1) { rt.asyncFnResumed(); @@ -1576,32 +1574,32 @@ export class drainFuture { } else { if (this.#state === 3) { bb0 = 7; - continue l0; + continue; } if (this.#state === 4) { bb0 = 15; - continue l0; + continue; } bb0 = 22; - continue l0; + continue; } case 1: if (this.#depth$2 === 1) { unwind = 36; this.#awaitee = new recvFuture(this.#rx$2); bb0 = 7; - continue l0; + continue; } if (this.#depth$2 === 4) { unwind = 36; this.#awaitee$2 = new level3Future(this.#rx$2); bb0 = 15; - continue l0; + continue; } unwind = 36; this.#awaitee$3 = new level15Future(this.#rx$2); bb0 = 22; - continue l0; + continue; case 22: unwind = 33; const _29: rt.Poll = this.#awaitee$3.poll(_2); @@ -1610,7 +1608,7 @@ export class drainFuture { next = _29; rt.drop(this.#awaitee$3); bb0 = 27; - continue l0; + continue; } this.#state = 5; return rt.Pending; @@ -1622,7 +1620,7 @@ export class drainFuture { next = _18; rt.drop(this.#awaitee$2); bb0 = 27; - continue l0; + continue; } this.#state = 4; return rt.Pending; @@ -1634,7 +1632,7 @@ export class drainFuture { next = _7; rt.drop(this.#awaitee); bb0 = 27; - continue l0; + continue; } this.#state = 3; return rt.Pending; @@ -1648,7 +1646,7 @@ export class drainFuture { } this.#total = rt.u64Add(this.#total, next); bb0 = 1; - continue l0; + continue; } } } catch (e) { diff --git a/ts/src/lower/mir/cfg.rs b/ts/src/lower/mir/cfg.rs index 1e1273306..06e1a8d5b 100644 --- a/ts/src/lower/mir/cfg.rs +++ b/ts/src/lower/mir/cfg.rs @@ -43,6 +43,8 @@ struct Shape { idom: Vec, /// Each node's dominator-tree children, in reverse postorder. children: Vec>, + /// Whether each node is placed after the loop its dominator heads, which it leaves. + exit: Vec, /// How many reachable predecessors reach each node by a forward edge. forward: Vec, /// Whether a back edge targets each node. @@ -116,10 +118,6 @@ impl Shape { } } } - let mut children = vec![Vec::new(); n]; - for &node in order.iter().skip(1) { - children[idom[node]].push(node); - } let dominates = |a: usize, mut b: usize| loop { if a == b { return true; @@ -142,11 +140,64 @@ impl Shape { } } } + // Each loop's nodes: what reaches a back edge's source without passing its header. + // Only a reducible graph is placed as a tree. + let mut body: Vec>> = vec![None; n]; + for &node in order.iter().filter(|_| reducible) { + for &next in &g.succs[node] { + if rpo[next] > rpo[node] { + continue; + } + let nodes = body[next].get_or_insert_with(|| { + let mut nodes = vec![false; n]; + nodes[next] = true; + nodes + }); + let mut stack = vec![node]; + while let Some(m) = stack.pop() { + if !std::mem::replace(&mut nodes[m], true) { + stack.extend(&preds[m]); + } + } + } + } + // The loop whose test each node is part of: its header, and the nodes after it + // that one way in and one way on lead to, up to its first branch. + let mut test = vec![usize::MAX; n]; + for &h in &order { + let Some(b) = &body[h] else { + continue; + }; + let mut node = h; + loop { + test[node] = h; + match g.succs[node].as_slice() { + &[next] if b[next] && !header[next] && preds[next].len() == 1 => node = next, + _ => break, + } + } + } + // Where a loop's test leaves it, what follows is placed after the loop, which a + // `break` leaves, rather than in the branch. Other ways out, often a `return` from + // within, stay where they leave. + let mut children = vec![Vec::new(); n]; + let mut exit = vec![false; n]; + for &node in order.iter().skip(1) { + let d = idom[node]; + match test[d] { + h if h != usize::MAX && !body[h].as_ref().is_some_and(|b| b[node]) => { + children[h].push(node); + exit[node] = true; + } + _ => children[d].push(node), + } + } Self { rpo, order, idom, children, + exit, forward, header, reducible, @@ -201,31 +252,50 @@ impl Ramsey<'_, L> { /// `x` and what it dominates. fn tree(&mut self, x: usize, out: &mut Vec) { - // The merge nodes it dominates, the last in reverse postorder outermost. - let mut merges: Vec = self.shape.children[x] + // The nodes placed after its loop, and the merge nodes it dominates within it, + // the last in reverse postorder outermost. + let (mut exits, mut merges): (Vec, Vec) = self.shape.children[x] .iter() .copied() - .filter(|&c| self.shape.merge(c)) - .collect(); + .filter(|&c| self.shape.exit[c] || self.shape.merge(c)) + .partition(|&c| self.shape.exit[c]); + exits.sort_by_key(|&c| std::cmp::Reverse(self.shape.rpo[c])); merges.sort_by_key(|&c| std::cmp::Reverse(self.shape.rpo[c])); match self.shape.header[x] { - true => { - let label = self.label(x, "l"); - let mut body = Vec::new(); - self.within(x, &merges, &mut body); - out.push( - StmtKind::While { - label: Some(label), - cond: Expr::lit("true"), - body, - } - .at(None), - ); - } + true => self.after(x, &exits, &merges, out), false => self.within(x, &merges, out), } } + /// `x`'s loop, in a block for each node placed after it. + fn after(&mut self, x: usize, exits: &[usize], merges: &[usize], out: &mut Vec) { + if let [y, rest @ ..] = exits { + let label = self.label(*y, "b"); + let mut body = Vec::new(); + self.after(x, rest, merges, &mut body); + out.push( + StmtKind::Block { + label: Some(label), + body, + } + .at(None), + ); + self.tree(*y, out); + return; + } + let label = self.label(x, "l"); + let mut body = Vec::new(); + self.within(x, merges, &mut body); + out.push( + StmtKind::While { + label: Some(label), + cond: Expr::lit("true"), + body, + } + .at(None), + ); + } + fn within(&mut self, x: usize, merges: &[usize], out: &mut Vec) { if let [y, rest @ ..] = merges { let label = self.label(*y, "b"); @@ -262,7 +332,7 @@ impl Ramsey<'_, L> { self.lower.flush(out); let label = self.label(to, "l"); out.push(StmtKind::Continue(Some(label)).at(None)); - } else if self.shape.merge(to) { + } else if self.shape.merge(to) || self.shape.exit[to] { self.lower.flush(out); let label = self.label(to, "b"); out.push(StmtKind::Break(Some(label)).at(None)); @@ -386,6 +456,7 @@ pub fn simplify(stmts: &mut Vec) { if let Some(l) = label { strip_tail(body, &StmtKind::Continue(Some(l.clone()))); } + strip_tail(body, &StmtKind::Continue(None)); } StmtKind::If { then, els, .. } => { simplify(then); @@ -479,6 +550,137 @@ pub fn hoist_else(stmts: &mut Vec) { } } +/// Last, as the passes before match labeled jumps: a loop takes the label of a block that +/// holds only it, a loop that starts by leaving when `c` holds runs `while (!c)`, and a +/// jump to the innermost loop it is in names no label. +pub fn tidy_loops(stmts: &mut Vec) { + adopt_labels(stmts); + simplify(stmts); + rotate(stmts); + unlabel(stmts, None, false); + simplify(stmts); +} + +/// `b: { l: while (..) { .. break b .. } }` is `l: while (..) { .. break l .. }`. +fn adopt_labels(stmts: &mut [Stmt]) { + for stmt in stmts.iter_mut() { + if let StmtKind::Block { label: Some(b), body } = &mut stmt.kind + && let [loop_] = body.as_mut_slice() + && let StmtKind::While { label, body, .. } = &mut loop_.kind + { + let l = label.get_or_insert_with(|| b.clone()).clone(); + retarget(body, b, &l); + stmt.kind = std::mem::replace(&mut loop_.kind, StmtKind::Break(None)); + } + match &mut stmt.kind { + StmtKind::If { then, els, .. } => { + adopt_labels(then); + adopt_labels(els); + } + StmtKind::Block { body, .. } | StmtKind::While { body, .. } => adopt_labels(body), + StmtKind::Switch { cases, default, .. } => { + cases.iter_mut().for_each(|(_, body)| adopt_labels(body)); + adopt_labels(default); + } + StmtKind::Catch { body, handler, .. } => { + adopt_labels(body); + adopt_labels(handler); + } + _ => {} + } + } +} + +/// Point each `break from` in `stmts` at `to`. +fn retarget(stmts: &mut [Stmt], from: &str, to: &str) { + for stmt in stmts.iter_mut() { + match &mut stmt.kind { + StmtKind::Break(Some(l)) if l == from => *l = to.to_string(), + StmtKind::If { then, els, .. } => { + retarget(then, from, to); + retarget(els, from, to); + } + StmtKind::Block { body, .. } | StmtKind::While { body, .. } => retarget(body, from, to), + StmtKind::Switch { cases, default, .. } => { + cases.iter_mut().for_each(|(_, body)| retarget(body, from, to)); + retarget(default, from, to); + } + StmtKind::Catch { body, handler, .. } => { + retarget(body, from, to); + retarget(handler, from, to); + } + _ => {} + } + } +} + +/// `while (true) { if (c) break; .. }` is `while (!c) { .. }`, and +/// `while (true) { if (c) { a } else break; .. }` is `while (c) { a .. }`. +fn rotate(stmts: &mut [Stmt]) { + for stmt in stmts.iter_mut() { + if let StmtKind::While { label, cond, body } = &mut stmt.kind + && matches!(cond, Expr::Lit(l) if l == "true") + && let Some(StmtKind::If { cond: test, then, els }) = body.first_mut().map(|s| &mut s.kind) + { + let leaves = |stmts: &[Stmt]| { + matches!(stmts, [Stmt { kind: StmtKind::Break(target), .. }] + if target.is_none() || target == label) + }; + if els.is_empty() && leaves(then) { + *cond = std::mem::replace(test, Expr::undefined()).not(); + body.remove(0); + } else if leaves(els) { + *cond = std::mem::replace(test, Expr::undefined()); + let then = std::mem::take(then); + body.splice(0..1, then); + } + } + match &mut stmt.kind { + StmtKind::If { then, els, .. } => { + rotate(then); + rotate(els); + } + StmtKind::Block { body, .. } | StmtKind::While { body, .. } => rotate(body), + StmtKind::Switch { cases, default, .. } => { + cases.iter_mut().for_each(|(_, body)| rotate(body)); + rotate(default); + } + StmtKind::Catch { body, handler, .. } => { + rotate(body); + rotate(handler); + } + _ => {} + } + } +} + +/// Drop the label of each jump to `innermost`, the loop `stmts` are in, which an +/// unlabeled `break` in a `switch` would leave instead. +fn unlabel(stmts: &mut [Stmt], innermost: Option<&str>, in_switch: bool) { + for stmt in stmts.iter_mut() { + match &mut stmt.kind { + StmtKind::Continue(l) if l.is_some() && l.as_deref() == innermost => *l = None, + StmtKind::Break(l) if !in_switch && l.is_some() && l.as_deref() == innermost => *l = None, + StmtKind::If { then, els, .. } => { + unlabel(then, innermost, in_switch); + unlabel(els, innermost, in_switch); + } + StmtKind::Block { body, .. } => unlabel(body, innermost, in_switch), + // An unlabeled loop matches no jump's label. + StmtKind::While { label, body, .. } => unlabel(body, Some(label.as_deref().unwrap_or("")), false), + StmtKind::Switch { cases, default, .. } => { + cases.iter_mut().for_each(|(_, body)| unlabel(body, innermost, true)); + unlabel(default, innermost, true); + } + StmtKind::Catch { body, handler, .. } => { + unlabel(body, innermost, in_switch); + unlabel(handler, innermost, in_switch); + } + _ => {} + } + } +} + /// Whether evaluating `e` does nothing but read. pub fn pure(e: &Expr) -> bool { match e { diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 78006d8a4..e92c70d25 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -1230,6 +1230,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } cfg::hoist_else(&mut out); declare_in_place(&mut out); + cfg::tidy_loops(&mut out); out }