From c533b7ee2855fab789eea70f749c78fed835b978 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 21:18:24 -0800 Subject: [PATCH 1/2] chore(quest): claim quest/m3/ts-operator-paths.md Quest-Claim: d597a5ad6d0afff3 From ceb9eed0477fa6e707b93a0f5ab30559338528e4 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 2 Nov 2026 21:27:01 -0800 Subject: [PATCH 2/2] feat(ts): translate std::ops operator methods on primitives called by path Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 1 - quest/m3/ts-operator-paths.md | 23 - ts/Cargo.lock | 4 + ts/fixtures/lang/operators/Cargo.toml | 14 + ts/fixtures/lang/operators/caller.ts | 62 + .../lang/operators/expected/core/option.ts | 12 + .../lang/operators/expected/harness.ts | 40 + ts/fixtures/lang/operators/expected/lib.ts | 14 + .../lang/operators/expected/operators.ts | 8980 +++++++++++++++++ ts/fixtures/lang/operators/src/lib.rs | 35 + ts/fixtures/lang/operators/src/operators.rs | 206 + ts/fixtures/lang/operators/ts.toml | 2 + ts/src/lower/library.rs | 11 +- ts/src/lower/mir/call.rs | 13 +- ts/tests/fixtures.rs | 1 + 15 files changed, 9388 insertions(+), 30 deletions(-) delete mode 100644 quest/m3/ts-operator-paths.md create mode 100644 ts/fixtures/lang/operators/Cargo.toml create mode 100644 ts/fixtures/lang/operators/caller.ts create mode 100644 ts/fixtures/lang/operators/expected/core/option.ts create mode 100644 ts/fixtures/lang/operators/expected/harness.ts create mode 100644 ts/fixtures/lang/operators/expected/lib.ts create mode 100644 ts/fixtures/lang/operators/expected/operators.ts create mode 100644 ts/fixtures/lang/operators/src/lib.rs create mode 100644 ts/fixtures/lang/operators/src/operators.rs create mode 100644 ts/fixtures/lang/operators/ts.toml diff --git a/quest/m3/README.md b/quest/m3/README.md index 5d90063f4..025a7703f 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -38,7 +38,6 @@ generic std gap is planned here even when moq never calls it. - [Rc and Arc of a slice](/quest/m3/ts-shared-slices.md) - `Rc<[T]>` and `Arc<[T]>` from a `Vec`, a slice, or an iterator translate - [Popping a String that is reassigned elsewhere](/quest/m3/ts-reassigned-pop.md) - `pop`, `remove`, and `split_off` of a local some other path assigns whole translate - [Whether a type needs drop](/quest/m3/ts-needs-drop.md) - `mem::needs_drop::()` translates as rustc's constant for each instance -- [Operator trait methods called by path](/quest/m3/ts-operator-paths.md) - `::add_assign` and every other `std::ops` operator method translate called by path or as a value - [The rest of a vector's methods](/quest/m3/ts-vec-rest.md) - `append`, `resize`, `split_off`, `try_reserve`, and `Vec::from(VecDeque)` translate - [A reversed zip's per-pair cost](/quest/m3/ts-zip-rev-overhead.md) - a reversed by-index zip costs per pair what a forward one does, or the gap is explained - [Whole writes into a lazy cell or thread-local key](/quest/m3/ts-lazy-writes.md) - a whole write through a `&mut` to a `LazyCell`, `LazyLock`, or `LocalKey` keeps its state diff --git a/quest/m3/ts-operator-paths.md b/quest/m3/ts-operator-paths.md deleted file mode 100644 index b75b0b09f..000000000 --- a/quest/m3/ts-operator-paths.md +++ /dev/null @@ -1,23 +0,0 @@ -# [S] Operator trait methods called by path - -## Goal - -[rust2-ts](/ts/README.md) translates each `std::ops` operator trait's method called by its -path, such as `::add_assign(&mut n, 1)` or `Add::add(a, b)`, wherever its -operator form translates, as a written call and as a function value -(`apply(AddAssign::add_assign, &mut n, 1)`). That covers every operator trait: the -arithmetic, bitwise, and shift ones, their `*Assign` forms, `Neg`, and `Not`. A differential -test against native Rust proves each call means what its operator does, overflow checks -and integer widths included. - -## Plan - -Found on 2026-11-02 completing [moq-dev/rust2#470](https://github.com/moq-dev/rust2/pull/470): -`::add_assign` called by path is an "unsupported call", written or as a value, -while `n += 1` translates. rustc lowers the operator on a primitive to a MIR binary op, but -a call by path stays a call to the trait method, which no mapping covers. - -Lowering std's primitive impls from their MIR may cover most of these, since their bodies are -the operator itself. Measure that against a mapping per trait. - -Public API: the translator's output. diff --git a/ts/Cargo.lock b/ts/Cargo.lock index e808baebe..8b96e3915 100644 --- a/ts/Cargo.lock +++ b/ts/Cargo.lock @@ -343,6 +343,10 @@ version = "0.0.0" name = "lang-objects-fixture" version = "0.0.0" +[[package]] +name = "lang-operators-fixture" +version = "0.0.0" + [[package]] name = "lang-orders-fixture" version = "0.0.0" diff --git a/ts/fixtures/lang/operators/Cargo.toml b/ts/fixtures/lang/operators/Cargo.toml new file mode 100644 index 000000000..0b815d7f2 --- /dev/null +++ b/ts/fixtures/lang/operators/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "lang-operators-fixture" +description = "A part of the language rust2-ts translates, exercised against native Rust" +version = "0.0.0" +edition.workspace = true +license.workspace = true +publish = false + +[lib] +# The cdylib is the native side of the differential test, built for wasm32. +crate-type = ["lib", "cdylib"] + +[lints] +workspace = true diff --git a/ts/fixtures/lang/operators/caller.ts b/ts/fixtures/lang/operators/caller.ts new file mode 100644 index 000000000..801282cdb --- /dev/null +++ b/ts/fixtures/lang/operators/caller.ts @@ -0,0 +1,62 @@ +// The inputs `operators`' cases name, which run with the generated ones. + +import { double, op } from "./lang.ts"; + +export { ops, run } from "./lang.ts"; + +/** + * `operators::*` of every integer kind at every width, over operands at the edges of its + * range: 0, 1, either end, the sign bit's neighbors, which make `MIN / -1`, and at 128 bits + * values past 2^64. Shift amounts are at, past, and many times past the width, and negative + * as an `i16`. Each form takes its turn at each pair. + */ +function ints(): Uint8Array[] { + const widths: [string, number][] = [["u8s", 8], ["u16s", 16], ["u32s", 32], ["u64s", 64], ["u128s", 128], ["usizes", 32], ["i8s", 8], ["i16s", 16], ["i32s", 32], ["i64s", 64], ["i128s", 128], ["isizes", 32]]; + const cases: Uint8Array[] = []; + for (const [name, bits] of widths) { + const o = op(`operators::${name}`); + const width = BigInt(bits); + const mask = (1n << width) - 1n; + const sign = 1n << (width - 1n); + const edges = [0n, 1n, 3n, mask, mask - 1n, sign, sign - 1n, sign + 1n]; + if (bits === 128) edges.push(1n << 64n, (1n << 64n) + 3n, 0x9e3779b97f4a7c150123456789abcdefn); + const be = (v: bigint) => Array.from({ length: bits / 8 }, (_, i) => Number((v >> BigInt(bits - 8 - 8 * i)) & 0xffn)); + // The amount's low byte and its high byte, which reads as `high << 24`; `0xff` + // reads as a negative `i16`. + const shifts = [[0, 0], [1, 0], [bits - 1, 0], [bits, 0], [bits + 1, 0], [2 * bits + 3, 0], [5, 1], [0xff, 0x80]]; + let i = 0; + for (const a of edges) { + for (const b of edges) { + const [low, high] = shifts[i % shifts.length]; + for (let kind = 0; kind < 32; kind++) cases.push(Uint8Array.of(...o, kind, (i + kind) % 6, ...be(a), ...be(b), low, high)); + i++; + } + } + } + return cases; +} + +/** Signed zeros, rounding, each type's extremes and subnormals, infinities, and NaN. */ +const doubles = [0, -0, 1, -1, 0.1, 1 / 3, 1.5, -2.5, 2 ** 53, 3.4028235677973366e38, 1e-40, 5e-324, Number.MAX_VALUE, Infinity, -Infinity, NaN]; + +/** `operators::f64s` and `f32s` of every kind, over each pair of doubles. */ +function floats(): Uint8Array[] { + const cases: Uint8Array[] = []; + for (const name of ["f64s", "f32s"]) { + const o = op(`operators::${name}`); + let i = 0; + for (const a of doubles) { + for (const b of doubles) { + for (let kind = 0; kind < 16; kind++) cases.push(Uint8Array.of(...o, kind, (i + kind) % 6, ...double(a), ...double(b))); + i++; + } + } + } + return cases; +} + +/** `operators::bools` of every kind, pair, and form. */ +const boolsOp = op("operators::bools"); +const bools = Array.from({ length: 10 * 6 * 4 }, (_, i) => Uint8Array.of(...boolsOp, i % 10, Math.floor(i / 10) % 6, Math.floor(i / 60))); + +export const cases: Uint8Array[] = [...ints(), ...floats(), ...bools]; diff --git a/ts/fixtures/lang/operators/expected/core/option.ts b/ts/fixtures/lang/operators/expected/core/option.ts new file mode 100644 index 000000000..0fb1b6278 --- /dev/null +++ b/ts/fixtures/lang/operators/expected/core/option.ts @@ -0,0 +1,12 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "../rt.ts"; + +export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return self; +} + +//# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/operators/expected/harness.ts b/ts/fixtures/lang/operators/expected/harness.ts new file mode 100644 index 000000000..58ec1cf62 --- /dev/null +++ b/ts/fixtures/lang/operators/expected/harness.ts @@ -0,0 +1,40 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { cases } from "./lib.ts"; + +/** Run one case. */ +export function run(input: rt.ByteSlice): rt.ByteVec { + const out: rt.ByteVec = new rt.ByteVec(); + if (!(input.length >= 3)) { + return out; + } + const cases_: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined][] = cases(); + cases_[rt.idx(cases_, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + return out; +} + +/** + * The first two bytes, as one big-endian number, that pick the case named `name`, which + * `lang.ts` targets by. + */ +export function op(name: string): rt.u16 { + const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases()), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { + return _2[0] === name; + }); + if (_11 !== undefined) { + const _20: rt.Result = rt.u16TryFrom(_11); + if (_20.ok) { + if ((_20.value >> 8) !== 255) { + return _20.value; + } + } + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; + rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + } else { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; + rt.panicFmt(["no case ", args2[0]]); + } +} + +//# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/operators/expected/lib.ts b/ts/fixtures/lang/operators/expected/lib.ts new file mode 100644 index 000000000..af3be3d05 --- /dev/null +++ b/ts/fixtures/lang/operators/expected/lib.ts @@ -0,0 +1,14 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { u8s, u16s, u32s, u64s, u128s, usizes, i8s, i16s, i32s, i64s, i128s, isizes, f64s, f32s, bools } from "./operators.ts"; + +/** + * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo + * their count, so a case added at the end moves no other. + */ +export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined][] { + return [["operators::u8s", u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::u16s", u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::u32s", u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::u64s", u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::u128s", u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::usizes", usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i8s", i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i16s", i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i32s", i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i64s", i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i128s", i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::isizes", isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::f64s", f64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::f32s", f32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::bools", bools as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; +} + +//# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/operators/expected/operators.ts b/ts/fixtures/lang/operators/expected/operators.ts new file mode 100644 index 000000000..480f3bcd5 --- /dev/null +++ b/ts/fixtures/lang/operators/expected/operators.ts @@ -0,0 +1,8980 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; + +/** `f(a)`, as a generic body calls a function value. */ +export function one$bool_bool_ops_Not_not_bool(_: (a0: boolean) => boolean, a: boolean): boolean { + return !a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$f32_f32_ops_Neg_neg_f32(_: (a0: rt.f32) => rt.f32, a: rt.f32): rt.f32 { + return -a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$f64_f64_ops_Neg_neg_f64(_: (a0: rt.f64) => rt.f64, a: rt.f64): rt.f64 { + return -a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i128_i128_ops_Neg_neg_i128(_: (a0: rt.i128) => rt.i128, a: rt.i128): rt.i128 { + return rt.i128Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i128_i128_ops_Not_not_i128(_: (a0: rt.i128) => rt.i128, a: rt.i128): rt.i128 { + return rt.i128Not(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i16_i16_ops_Neg_neg_i16(_: (a0: rt.i16) => rt.i16, a: rt.i16): rt.i16 { + return rt.i16Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i16_i16_ops_Not_not_i16(_: (a0: rt.i16) => rt.i16, a: rt.i16): rt.i16 { + return ~a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i32_i32_ops_Neg_neg_i32(_: (a0: rt.i32) => rt.i32, a: rt.i32): rt.i32 { + return rt.i32Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i32_i32_ops_Not_not_i32(_: (a0: rt.i32) => rt.i32, a: rt.i32): rt.i32 { + return ~a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i64_i64_ops_Neg_neg_i64(_: (a0: rt.i64) => rt.i64, a: rt.i64): rt.i64 { + return rt.i64Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i64_i64_ops_Not_not_i64(_: (a0: rt.i64) => rt.i64, a: rt.i64): rt.i64 { + return rt.i64Not(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i8_i8_ops_Neg_neg_i8(_: (a0: rt.i8) => rt.i8, a: rt.i8): rt.i8 { + return rt.i8Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$i8_i8_ops_Not_not_i8(_: (a0: rt.i8) => rt.i8, a: rt.i8): rt.i8 { + return ~a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$isize_isize_ops_Neg_neg_isize(_: (a0: rt.isize) => rt.isize, a: rt.isize): rt.isize { + return rt.isizeNeg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$isize_isize_ops_Not_not_isize(_: (a0: rt.isize) => rt.isize, a: rt.isize): rt.isize { + return ~a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_bool_bool_ops_Not_not_ref_bool(_: (a0: boolean) => boolean, a: boolean): boolean { + return !a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_f32_f32_ops_Neg_neg_ref_f32(_: (a0: rt.f32) => rt.f32, a: rt.f32): rt.f32 { + return -a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_f64_f64_ops_Neg_neg_ref_f64(_: (a0: rt.f64) => rt.f64, a: rt.f64): rt.f64 { + return -a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i128_i128_ops_Neg_neg_ref_i128(_: (a0: rt.i128) => rt.i128, a: rt.i128): rt.i128 { + return rt.i128Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i128_i128_ops_Not_not_ref_i128(_: (a0: rt.i128) => rt.i128, a: rt.i128): rt.i128 { + return rt.i128Not(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i16_i16_ops_Neg_neg_ref_i16(_: (a0: rt.i16) => rt.i16, a: rt.i16): rt.i16 { + return rt.i16Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i16_i16_ops_Not_not_ref_i16(_: (a0: rt.i16) => rt.i16, a: rt.i16): rt.i16 { + return ~a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i32_i32_ops_Neg_neg_ref_i32(_: (a0: rt.i32) => rt.i32, a: rt.i32): rt.i32 { + return rt.i32Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i32_i32_ops_Not_not_ref_i32(_: (a0: rt.i32) => rt.i32, a: rt.i32): rt.i32 { + return ~a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i64_i64_ops_Neg_neg_ref_i64(_: (a0: rt.i64) => rt.i64, a: rt.i64): rt.i64 { + return rt.i64Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i64_i64_ops_Not_not_ref_i64(_: (a0: rt.i64) => rt.i64, a: rt.i64): rt.i64 { + return rt.i64Not(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i8_i8_ops_Neg_neg_ref_i8(_: (a0: rt.i8) => rt.i8, a: rt.i8): rt.i8 { + return rt.i8Neg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_i8_i8_ops_Not_not_ref_i8(_: (a0: rt.i8) => rt.i8, a: rt.i8): rt.i8 { + return ~a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_isize_isize_ops_Neg_neg_ref_isize(_: (a0: rt.isize) => rt.isize, a: rt.isize): rt.isize { + return rt.isizeNeg(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_isize_isize_ops_Not_not_ref_isize(_: (a0: rt.isize) => rt.isize, a: rt.isize): rt.isize { + return ~a; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_u128_u128_ops_Not_not_ref_u128(_: (a0: rt.u128) => rt.u128, a: rt.u128): rt.u128 { + return rt.u128Not(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_u16_u16_ops_Not_not_ref_u16(_: (a0: rt.u16) => rt.u16, a: rt.u16): rt.u16 { + return ~a & 0xffff; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_u32_u32_ops_Not_not_ref_u32(_: (a0: rt.u32) => rt.u32, a: rt.u32): rt.u32 { + return ~a >>> 0; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_u64_u64_ops_Not_not_ref_u64(_: (a0: rt.u64) => rt.u64, a: rt.u64): rt.u64 { + return rt.u64Not(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_u8_u8_ops_Not_not_ref_u8(_: (a0: rt.u8) => rt.u8, a: rt.u8): rt.u8 { + return ~a & 0xff; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$ref_usize_usize_ops_Not_not_ref_usize(_: (a0: rt.usize) => rt.usize, a: rt.usize): rt.usize { + return ~a >>> 0; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$u128_u128_ops_Not_not_u128(_: (a0: rt.u128) => rt.u128, a: rt.u128): rt.u128 { + return rt.u128Not(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$u16_u16_ops_Not_not_u16(_: (a0: rt.u16) => rt.u16, a: rt.u16): rt.u16 { + return ~a & 0xffff; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$u32_u32_ops_Not_not_u32(_: (a0: rt.u32) => rt.u32, a: rt.u32): rt.u32 { + return ~a >>> 0; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$u64_u64_ops_Not_not_u64(_: (a0: rt.u64) => rt.u64, a: rt.u64): rt.u64 { + return rt.u64Not(a); +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$u8_u8_ops_Not_not_u8(_: (a0: rt.u8) => rt.u8, a: rt.u8): rt.u8 { + return ~a & 0xff; +} + +/** `f(a)`, as a generic body calls a function value. */ +export function one$usize_usize_ops_Not_not_usize(_: (a0: rt.usize) => rt.usize, a: rt.usize): rt.usize { + return ~a >>> 0; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$bool_bool_bool_ops_BitAnd_bitand_bool_bool(_: (a0: boolean, a1: boolean) => boolean, a: boolean, b: boolean): boolean { + return a && b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$bool_bool_bool_ops_BitOr_bitor_bool_bool(_: (a0: boolean, a1: boolean) => boolean, a: boolean, b: boolean): boolean { + return a || b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$bool_bool_bool_ops_BitXor_bitxor_bool_bool(_: (a0: boolean, a1: boolean) => boolean, a: boolean, b: boolean): boolean { + return a !== b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f32_f32_f32_ops_Add_add_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { + return Math.fround(a + b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f32_f32_f32_ops_Div_div_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { + return Math.fround(a / b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f32_f32_f32_ops_Mul_mul_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { + return Math.fround(a * b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f32_f32_f32_ops_Rem_rem_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { + return a % b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f32_f32_f32_ops_Sub_sub_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { + return Math.fround(a - b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f32_ref_f32_f32_ops_Rem_rem_f32_ref_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { + return a % b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f64_f64_f64_ops_Add_add_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { + return a + b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f64_f64_f64_ops_Div_div_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { + return a / b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f64_f64_f64_ops_Mul_mul_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { + return a * b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f64_f64_f64_ops_Rem_rem_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { + return a % b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f64_f64_f64_ops_Sub_sub_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { + return a - b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$f64_ref_f64_f64_ops_Rem_rem_f64_ref_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { + return a % b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i128_i128_ops_Add_add_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i128_i128_ops_BitAnd_bitand_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128And(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i128_i128_ops_BitOr_bitor_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Or(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i128_i128_ops_BitXor_bitxor_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Xor(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i128_i128_ops_Div_div_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i128_i128_ops_Mul_mul_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i128_i128_ops_Rem_rem_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i128_i128_ops_Sub_sub_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_i16_i128_ops_Shl_shl_i128_i16(_: (a0: rt.i128, a1: rt.i16) => rt.i128, a: rt.i128, b: rt.i16): rt.i128 { + return rt.i128Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_ref_i128_i128_ops_Add_add_i128_ref_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_u128_i128_ops_Shr_shr_i128_u128(_: (a0: rt.i128, a1: rt.u128) => rt.i128, a: rt.i128, b: rt.u128): rt.i128 { + return rt.i128Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_u32_i128_ops_Shl_shl_i128_u32(_: (a0: rt.i128, a1: rt.u32) => rt.i128, a: rt.i128, b: rt.u32): rt.i128 { + return rt.i128Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i128_u32_i128_ops_Shr_shr_i128_u32(_: (a0: rt.i128, a1: rt.u32) => rt.i128, a: rt.i128, b: rt.u32): rt.i128 { + return rt.i128Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_Add_add_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_BitAnd_bitand_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return a & b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_BitOr_bitor_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return a | b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_BitXor_bitxor_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return a ^ b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_Div_div_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_Mul_mul_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_Rem_rem_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_Shl_shl_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_i16_i16_ops_Sub_sub_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_ref_i16_i16_ops_Add_add_i16_ref_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_u128_i16_ops_Shr_shr_i16_u128(_: (a0: rt.i16, a1: rt.u128) => rt.i16, a: rt.i16, b: rt.u128): rt.i16 { + return rt.i16Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_u32_i16_ops_Shl_shl_i16_u32(_: (a0: rt.i16, a1: rt.u32) => rt.i16, a: rt.i16, b: rt.u32): rt.i16 { + return rt.i16Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i16_u32_i16_ops_Shr_shr_i16_u32(_: (a0: rt.i16, a1: rt.u32) => rt.i16, a: rt.i16, b: rt.u32): rt.i16 { + return rt.i16Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i16_i32_ops_Shl_shl_i32_i16(_: (a0: rt.i32, a1: rt.i16) => rt.i32, a: rt.i32, b: rt.i16): rt.i32 { + return rt.i32Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i32_i32_ops_Add_add_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return rt.i32Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i32_i32_ops_BitAnd_bitand_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return a & b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i32_i32_ops_BitOr_bitor_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return a | b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i32_i32_ops_BitXor_bitxor_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return a ^ b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i32_i32_ops_Div_div_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return rt.i32Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i32_i32_ops_Mul_mul_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return rt.i32Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i32_i32_ops_Rem_rem_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return rt.i32Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_i32_i32_ops_Sub_sub_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return rt.i32Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_ref_i32_i32_ops_Add_add_i32_ref_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return rt.i32Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_u128_i32_ops_Shr_shr_i32_u128(_: (a0: rt.i32, a1: rt.u128) => rt.i32, a: rt.i32, b: rt.u128): rt.i32 { + return rt.i32Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_u32_i32_ops_Shl_shl_i32_u32(_: (a0: rt.i32, a1: rt.u32) => rt.i32, a: rt.i32, b: rt.u32): rt.i32 { + return rt.i32Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i32_u32_i32_ops_Shr_shr_i32_u32(_: (a0: rt.i32, a1: rt.u32) => rt.i32, a: rt.i32, b: rt.u32): rt.i32 { + return rt.i32Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i16_i64_ops_Shl_shl_i64_i16(_: (a0: rt.i64, a1: rt.i16) => rt.i64, a: rt.i64, b: rt.i16): rt.i64 { + return rt.i64Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i64_i64_ops_Add_add_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i64_i64_ops_BitAnd_bitand_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64And(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i64_i64_ops_BitOr_bitor_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Or(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i64_i64_ops_BitXor_bitxor_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Xor(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i64_i64_ops_Div_div_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i64_i64_ops_Mul_mul_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i64_i64_ops_Rem_rem_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_i64_i64_ops_Sub_sub_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_ref_i64_i64_ops_Add_add_i64_ref_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_u128_i64_ops_Shr_shr_i64_u128(_: (a0: rt.i64, a1: rt.u128) => rt.i64, a: rt.i64, b: rt.u128): rt.i64 { + return rt.i64Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_u32_i64_ops_Shl_shl_i64_u32(_: (a0: rt.i64, a1: rt.u32) => rt.i64, a: rt.i64, b: rt.u32): rt.i64 { + return rt.i64Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i64_u32_i64_ops_Shr_shr_i64_u32(_: (a0: rt.i64, a1: rt.u32) => rt.i64, a: rt.i64, b: rt.u32): rt.i64 { + return rt.i64Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i16_i8_ops_Shl_shl_i8_i16(_: (a0: rt.i8, a1: rt.i16) => rt.i8, a: rt.i8, b: rt.i16): rt.i8 { + return rt.i8Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i8_i8_ops_Add_add_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return rt.i8Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i8_i8_ops_BitAnd_bitand_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return a & b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i8_i8_ops_BitOr_bitor_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return a | b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i8_i8_ops_BitXor_bitxor_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return a ^ b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i8_i8_ops_Div_div_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return rt.i8Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i8_i8_ops_Mul_mul_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return rt.i8Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i8_i8_ops_Rem_rem_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return rt.i8Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_i8_i8_ops_Sub_sub_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return rt.i8Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_ref_i8_i8_ops_Add_add_i8_ref_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return rt.i8Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_u128_i8_ops_Shr_shr_i8_u128(_: (a0: rt.i8, a1: rt.u128) => rt.i8, a: rt.i8, b: rt.u128): rt.i8 { + return rt.i8Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_u32_i8_ops_Shl_shl_i8_u32(_: (a0: rt.i8, a1: rt.u32) => rt.i8, a: rt.i8, b: rt.u32): rt.i8 { + return rt.i8Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$i8_u32_i8_ops_Shr_shr_i8_u32(_: (a0: rt.i8, a1: rt.u32) => rt.i8, a: rt.i8, b: rt.u32): rt.i8 { + return rt.i8Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_i16_isize_ops_Shl_shl_isize_i16(_: (a0: rt.isize, a1: rt.i16) => rt.isize, a: rt.isize, b: rt.i16): rt.isize { + return rt.isizeShl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_isize_isize_ops_Add_add_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return rt.isizeAdd(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_isize_isize_ops_BitAnd_bitand_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return a & b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_isize_isize_ops_BitOr_bitor_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return a | b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_isize_isize_ops_BitXor_bitxor_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return a ^ b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_isize_isize_ops_Div_div_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return rt.isizeDiv(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_isize_isize_ops_Mul_mul_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return rt.isizeMul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_isize_isize_ops_Rem_rem_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return rt.isizeRem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_isize_isize_ops_Sub_sub_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return rt.isizeSub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_ref_isize_isize_ops_Add_add_isize_ref_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return rt.isizeAdd(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_u128_isize_ops_Shr_shr_isize_u128(_: (a0: rt.isize, a1: rt.u128) => rt.isize, a: rt.isize, b: rt.u128): rt.isize { + return rt.isizeShr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_u32_isize_ops_Shl_shl_isize_u32(_: (a0: rt.isize, a1: rt.u32) => rt.isize, a: rt.isize, b: rt.u32): rt.isize { + return rt.isizeShl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$isize_u32_isize_ops_Shr_shr_isize_u32(_: (a0: rt.isize, a1: rt.u32) => rt.isize, a: rt.isize, b: rt.u32): rt.isize { + return rt.isizeShr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_bool_bool_unit_ops_BitAndAssign_bitand_assign_bool_bool(_: (a0: rt.Place, a1: boolean) => undefined, a: rt.Place, b: boolean): void { + ((a0: rt.Place, a1: boolean): undefined => { + a0.v = a0.v && a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_bool_bool_unit_ops_BitOrAssign_bitor_assign_bool_bool(_: (a0: rt.Place, a1: boolean) => undefined, a: rt.Place, b: boolean): void { + ((a0: rt.Place, a1: boolean): undefined => { + a0.v = a0.v || a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_bool_bool_unit_ops_BitXorAssign_bitxor_assign_bool_bool(_: (a0: rt.Place, a1: boolean) => undefined, a: rt.Place, b: boolean): void { + ((a0: rt.Place, a1: boolean): undefined => { + a0.v = a0.v !== a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_bool_ref_bool_unit_ops_BitOrAssign_bitor_assign_bool_ref_bool(_: (a0: rt.Place, a1: boolean) => undefined, a: rt.Place, b: boolean): void { + ((a0: rt.Place, a1: boolean): undefined => { + a0.v = a0.v || a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f32_f32_unit_ops_AddAssign_add_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { + ((a0: rt.Place, a1: rt.f32): undefined => { + a0.v = Math.fround(a0.v + a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f32_f32_unit_ops_DivAssign_div_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { + ((a0: rt.Place, a1: rt.f32): undefined => { + a0.v = Math.fround(a0.v / a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f32_f32_unit_ops_MulAssign_mul_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { + ((a0: rt.Place, a1: rt.f32): undefined => { + a0.v = Math.fround(a0.v * a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f32_f32_unit_ops_RemAssign_rem_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { + ((a0: rt.Place, a1: rt.f32): undefined => { + a0.v = a0.v % a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f32_f32_unit_ops_SubAssign_sub_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { + ((a0: rt.Place, a1: rt.f32): undefined => { + a0.v = Math.fround(a0.v - a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f32_ref_f32_unit_ops_MulAssign_mul_assign_f32_ref_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { + ((a0: rt.Place, a1: rt.f32): undefined => { + a0.v = Math.fround(a0.v * a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f32_ref_f32_unit_ops_RemAssign_rem_assign_f32_ref_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { + ((a0: rt.Place, a1: rt.f32): undefined => { + a0.v = a0.v % a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f64_f64_unit_ops_AddAssign_add_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { + ((a0: rt.Place, a1: rt.f64): undefined => { + a0.v = a0.v + a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f64_f64_unit_ops_DivAssign_div_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { + ((a0: rt.Place, a1: rt.f64): undefined => { + a0.v = a0.v / a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f64_f64_unit_ops_MulAssign_mul_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { + ((a0: rt.Place, a1: rt.f64): undefined => { + a0.v = a0.v * a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f64_f64_unit_ops_RemAssign_rem_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { + ((a0: rt.Place, a1: rt.f64): undefined => { + a0.v = a0.v % a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f64_f64_unit_ops_SubAssign_sub_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { + ((a0: rt.Place, a1: rt.f64): undefined => { + a0.v = a0.v - a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f64_ref_f64_unit_ops_MulAssign_mul_assign_f64_ref_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { + ((a0: rt.Place, a1: rt.f64): undefined => { + a0.v = a0.v * a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_f64_ref_f64_unit_ops_RemAssign_rem_assign_f64_ref_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { + ((a0: rt.Place, a1: rt.f64): undefined => { + a0.v = a0.v % a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i128_unit_ops_AddAssign_add_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i128_unit_ops_BitAndAssign_bitand_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128And(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i128_unit_ops_BitOrAssign_bitor_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Or(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i128_unit_ops_BitXorAssign_bitxor_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Xor(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i128_unit_ops_DivAssign_div_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i128_unit_ops_MulAssign_mul_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i128_unit_ops_RemAssign_rem_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i128_unit_ops_SubAssign_sub_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_i64_unit_ops_ShrAssign_shr_assign_i128_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i128Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_ref_i128_unit_ops_AddAssign_add_assign_i128_ref_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_ref_i128_unit_ops_DivAssign_div_assign_i128_ref_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { + ((a0: rt.Place, a1: rt.i128): undefined => { + a0.v = rt.i128Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_ref_u16_unit_ops_ShrAssign_shr_assign_i128_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i128Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i128_u32_unit_ops_ShlAssign_shl_assign_i128_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.i128Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i16_unit_ops_AddAssign_add_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = rt.i16Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i16_unit_ops_BitAndAssign_bitand_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = a0.v & a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i16_unit_ops_BitOrAssign_bitor_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = a0.v | a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i16_unit_ops_BitXorAssign_bitxor_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = a0.v ^ a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i16_unit_ops_DivAssign_div_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = rt.i16Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i16_unit_ops_MulAssign_mul_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = rt.i16Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i16_unit_ops_RemAssign_rem_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = rt.i16Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i16_unit_ops_SubAssign_sub_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = rt.i16Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_i64_unit_ops_ShrAssign_shr_assign_i16_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i16Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_ref_i16_unit_ops_AddAssign_add_assign_i16_ref_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = rt.i16Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_ref_i16_unit_ops_DivAssign_div_assign_i16_ref_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { + ((a0: rt.Place, a1: rt.i16): undefined => { + a0.v = rt.i16Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_ref_u16_unit_ops_ShrAssign_shr_assign_i16_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i16Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i16_u32_unit_ops_ShlAssign_shl_assign_i16_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.i16Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i32_unit_ops_AddAssign_add_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = rt.i32Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i32_unit_ops_BitAndAssign_bitand_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = a0.v & a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i32_unit_ops_BitOrAssign_bitor_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = a0.v | a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i32_unit_ops_BitXorAssign_bitxor_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = a0.v ^ a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i32_unit_ops_DivAssign_div_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = rt.i32Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i32_unit_ops_MulAssign_mul_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = rt.i32Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i32_unit_ops_RemAssign_rem_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = rt.i32Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i32_unit_ops_SubAssign_sub_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = rt.i32Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_i64_unit_ops_ShrAssign_shr_assign_i32_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i32Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_ref_i32_unit_ops_AddAssign_add_assign_i32_ref_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = rt.i32Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_ref_i32_unit_ops_DivAssign_div_assign_i32_ref_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { + ((a0: rt.Place, a1: rt.i32): undefined => { + a0.v = rt.i32Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_ref_u16_unit_ops_ShrAssign_shr_assign_i32_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i32Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i32_u32_unit_ops_ShlAssign_shl_assign_i32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.i32Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_AddAssign_add_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_BitAndAssign_bitand_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64And(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_BitOrAssign_bitor_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Or(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_BitXorAssign_bitxor_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Xor(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_DivAssign_div_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_MulAssign_mul_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_RemAssign_rem_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_ShrAssign_shr_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_i64_unit_ops_SubAssign_sub_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_ref_i64_unit_ops_AddAssign_add_assign_i64_ref_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_ref_i64_unit_ops_DivAssign_div_assign_i64_ref_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i64Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_ref_u16_unit_ops_ShrAssign_shr_assign_i64_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i64Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i64_u32_unit_ops_ShlAssign_shl_assign_i64_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.i64Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i64_unit_ops_ShrAssign_shr_assign_i8_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.i8Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i8_unit_ops_AddAssign_add_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = rt.i8Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i8_unit_ops_BitAndAssign_bitand_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = a0.v & a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i8_unit_ops_BitOrAssign_bitor_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = a0.v | a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i8_unit_ops_BitXorAssign_bitxor_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = a0.v ^ a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i8_unit_ops_DivAssign_div_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = rt.i8Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i8_unit_ops_MulAssign_mul_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = rt.i8Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i8_unit_ops_RemAssign_rem_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = rt.i8Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_i8_unit_ops_SubAssign_sub_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = rt.i8Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_ref_i8_unit_ops_AddAssign_add_assign_i8_ref_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = rt.i8Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_ref_i8_unit_ops_DivAssign_div_assign_i8_ref_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { + ((a0: rt.Place, a1: rt.i8): undefined => { + a0.v = rt.i8Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_ref_u16_unit_ops_ShrAssign_shr_assign_i8_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i8Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_i8_u32_unit_ops_ShlAssign_shl_assign_i8_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.i8Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_i64_unit_ops_ShrAssign_shr_assign_isize_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.isizeShr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_isize_unit_ops_AddAssign_add_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = rt.isizeAdd(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_isize_unit_ops_BitAndAssign_bitand_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = a0.v & a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_isize_unit_ops_BitOrAssign_bitor_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = a0.v | a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_isize_unit_ops_BitXorAssign_bitxor_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = a0.v ^ a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_isize_unit_ops_DivAssign_div_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = rt.isizeDiv(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_isize_unit_ops_MulAssign_mul_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = rt.isizeMul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_isize_unit_ops_RemAssign_rem_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = rt.isizeRem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_isize_unit_ops_SubAssign_sub_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = rt.isizeSub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_ref_isize_unit_ops_AddAssign_add_assign_isize_ref_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = rt.isizeAdd(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_ref_isize_unit_ops_DivAssign_div_assign_isize_ref_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { + ((a0: rt.Place, a1: rt.isize): undefined => { + a0.v = rt.isizeDiv(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_ref_u16_unit_ops_ShrAssign_shr_assign_isize_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.isizeShr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_isize_u32_unit_ops_ShlAssign_shl_assign_isize_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.isizeShl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_i64_unit_ops_ShrAssign_shr_assign_u128_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.u128Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_ref_u128_unit_ops_AddAssign_add_assign_u128_ref_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_ref_u128_unit_ops_DivAssign_div_assign_u128_ref_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_ref_u16_unit_ops_ShrAssign_shr_assign_u128_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u128Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u128_unit_ops_AddAssign_add_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u128_unit_ops_BitAndAssign_bitand_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128And(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u128_unit_ops_BitOrAssign_bitor_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Or(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u128_unit_ops_BitXorAssign_bitxor_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Xor(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u128_unit_ops_DivAssign_div_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u128_unit_ops_MulAssign_mul_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u128_unit_ops_RemAssign_rem_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u128_unit_ops_SubAssign_sub_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { + ((a0: rt.Place, a1: rt.u128): undefined => { + a0.v = rt.u128Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u128_u32_unit_ops_ShlAssign_shl_assign_u128_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u128Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_i64_unit_ops_ShrAssign_shr_assign_u16_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.u16Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_ref_u16_unit_ops_AddAssign_add_assign_u16_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_ref_u16_unit_ops_DivAssign_div_assign_u16_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_ref_u16_unit_ops_ShrAssign_shr_assign_u16_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u16_unit_ops_AddAssign_add_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u16_unit_ops_BitAndAssign_bitand_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = a0.v & a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u16_unit_ops_BitOrAssign_bitor_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = a0.v | a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u16_unit_ops_BitXorAssign_bitxor_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = a0.v ^ a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u16_unit_ops_DivAssign_div_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u16_unit_ops_MulAssign_mul_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u16_unit_ops_RemAssign_rem_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u16_unit_ops_SubAssign_sub_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u16_u32_unit_ops_ShlAssign_shl_assign_u16_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u16Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_i64_unit_ops_ShrAssign_shr_assign_u32_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.u32Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_ref_u16_unit_ops_ShrAssign_shr_assign_u32_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u32Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_ref_u32_unit_ops_AddAssign_add_assign_u32_ref_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u32Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_ref_u32_unit_ops_DivAssign_div_assign_u32_ref_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u32Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_AddAssign_add_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u32Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_BitAndAssign_bitand_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = (a0.v & a1) >>> 0; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_BitOrAssign_bitor_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = (a0.v | a1) >>> 0; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_BitXorAssign_bitxor_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = (a0.v ^ a1) >>> 0; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_DivAssign_div_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u32Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_MulAssign_mul_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u32Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_RemAssign_rem_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u32Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_ShlAssign_shl_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u32Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u32_u32_unit_ops_SubAssign_sub_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u32Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_i64_unit_ops_ShrAssign_shr_assign_u64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.u64Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_ref_u16_unit_ops_ShrAssign_shr_assign_u64_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u64Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_ref_u64_unit_ops_AddAssign_add_assign_u64_ref_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_ref_u64_unit_ops_DivAssign_div_assign_u64_ref_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u32_unit_ops_ShlAssign_shl_assign_u64_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u64Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u64_unit_ops_AddAssign_add_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u64_unit_ops_BitAndAssign_bitand_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64And(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u64_unit_ops_BitOrAssign_bitor_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Or(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u64_unit_ops_BitXorAssign_bitxor_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Xor(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u64_unit_ops_DivAssign_div_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u64_unit_ops_MulAssign_mul_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u64_unit_ops_RemAssign_rem_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u64_u64_unit_ops_SubAssign_sub_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { + ((a0: rt.Place, a1: rt.u64): undefined => { + a0.v = rt.u64Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_i64_unit_ops_ShrAssign_shr_assign_u8_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.u8Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_ref_u16_unit_ops_ShrAssign_shr_assign_u8_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u8Shr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_ref_u8_unit_ops_AddAssign_add_assign_u8_ref_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = rt.u8Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_ref_u8_unit_ops_DivAssign_div_assign_u8_ref_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = rt.u8Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u32_unit_ops_ShlAssign_shl_assign_u8_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.u8Shl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u8_unit_ops_AddAssign_add_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = rt.u8Add(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u8_unit_ops_BitAndAssign_bitand_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = a0.v & a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u8_unit_ops_BitOrAssign_bitor_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = a0.v | a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u8_unit_ops_BitXorAssign_bitxor_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = a0.v ^ a1; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u8_unit_ops_DivAssign_div_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = rt.u8Div(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u8_unit_ops_MulAssign_mul_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = rt.u8Mul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u8_unit_ops_RemAssign_rem_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = rt.u8Rem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_u8_u8_unit_ops_SubAssign_sub_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { + ((a0: rt.Place, a1: rt.u8): undefined => { + a0.v = rt.u8Sub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_i64_unit_ops_ShrAssign_shr_assign_usize_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { + ((a0: rt.Place, a1: rt.i64): undefined => { + a0.v = rt.usizeShr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_ref_u16_unit_ops_ShrAssign_shr_assign_usize_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.usizeShr(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_ref_usize_unit_ops_AddAssign_add_assign_usize_ref_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = rt.usizeAdd(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_ref_usize_unit_ops_DivAssign_div_assign_usize_ref_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = rt.usizeDiv(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_u32_unit_ops_ShlAssign_shl_assign_usize_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { + ((a0: rt.Place, a1: rt.u32): undefined => { + a0.v = rt.usizeShl(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_usize_unit_ops_AddAssign_add_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = rt.usizeAdd(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_usize_unit_ops_BitAndAssign_bitand_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = (a0.v & a1) >>> 0; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_usize_unit_ops_BitOrAssign_bitor_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = (a0.v | a1) >>> 0; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_usize_unit_ops_BitXorAssign_bitxor_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = (a0.v ^ a1) >>> 0; + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_usize_unit_ops_DivAssign_div_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = rt.usizeDiv(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_usize_unit_ops_MulAssign_mul_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = rt.usizeMul(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_usize_unit_ops_RemAssign_rem_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = rt.usizeRem(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$mut_usize_usize_unit_ops_SubAssign_sub_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { + ((a0: rt.Place, a1: rt.usize): undefined => { + a0.v = rt.usizeSub(a0.v, a1); + })(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_bool_ref_bool_bool_ops_BitAnd_bitand_ref_bool_ref_bool(_: (a0: boolean, a1: boolean) => boolean, a: boolean, b: boolean): boolean { + return a && b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_f32_ref_f32_f32_ops_Add_add_ref_f32_ref_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { + return Math.fround(a + b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_f64_ref_f64_f64_ops_Add_add_ref_f64_ref_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { + return a + b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i128_i128_i128_ops_Sub_sub_ref_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i128_ref_i128_i128_ops_Mul_mul_ref_i128_ref_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { + return rt.i128Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i128_ref_u8_i128_ops_Shl_shl_ref_i128_ref_u8(_: (a0: rt.i128, a1: rt.u8) => rt.i128, a: rt.i128, b: rt.u8): rt.i128 { + return rt.i128Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i16_i16_i16_ops_Sub_sub_ref_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i16_ref_i16_i16_ops_Mul_mul_ref_i16_ref_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { + return rt.i16Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i16_ref_u8_i16_ops_Shl_shl_ref_i16_ref_u8(_: (a0: rt.i16, a1: rt.u8) => rt.i16, a: rt.i16, b: rt.u8): rt.i16 { + return rt.i16Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i32_i32_i32_ops_Sub_sub_ref_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return rt.i32Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i32_ref_i32_i32_ops_Mul_mul_ref_i32_ref_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { + return rt.i32Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i32_ref_u8_i32_ops_Shl_shl_ref_i32_ref_u8(_: (a0: rt.i32, a1: rt.u8) => rt.i32, a: rt.i32, b: rt.u8): rt.i32 { + return rt.i32Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i64_i64_i64_ops_Sub_sub_ref_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i64_ref_i64_i64_ops_Mul_mul_ref_i64_ref_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { + return rt.i64Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i64_ref_u8_i64_ops_Shl_shl_ref_i64_ref_u8(_: (a0: rt.i64, a1: rt.u8) => rt.i64, a: rt.i64, b: rt.u8): rt.i64 { + return rt.i64Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i8_i8_i8_ops_Sub_sub_ref_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return rt.i8Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i8_ref_i8_i8_ops_Mul_mul_ref_i8_ref_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { + return rt.i8Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_i8_ref_u8_i8_ops_Shl_shl_ref_i8_ref_u8(_: (a0: rt.i8, a1: rt.u8) => rt.i8, a: rt.i8, b: rt.u8): rt.i8 { + return rt.i8Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_isize_isize_isize_ops_Sub_sub_ref_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return rt.isizeSub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_isize_ref_isize_isize_ops_Mul_mul_ref_isize_ref_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { + return rt.isizeMul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_isize_ref_u8_isize_ops_Shl_shl_ref_isize_ref_u8(_: (a0: rt.isize, a1: rt.u8) => rt.isize, a: rt.isize, b: rt.u8): rt.isize { + return rt.isizeShl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u128_ref_u128_u128_ops_Mul_mul_ref_u128_ref_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u128_ref_u8_u128_ops_Shl_shl_ref_u128_ref_u8(_: (a0: rt.u128, a1: rt.u8) => rt.u128, a: rt.u128, b: rt.u8): rt.u128 { + return rt.u128Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u128_u128_u128_ops_Sub_sub_ref_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u16_ref_u16_u16_ops_Mul_mul_ref_u16_ref_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return rt.u16Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u16_ref_u8_u16_ops_Shl_shl_ref_u16_ref_u8(_: (a0: rt.u16, a1: rt.u8) => rt.u16, a: rt.u16, b: rt.u8): rt.u16 { + return rt.u16Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u16_u16_u16_ops_Sub_sub_ref_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return rt.u16Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u32_ref_u32_u32_ops_Mul_mul_ref_u32_ref_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u32_ref_u8_u32_ops_Shl_shl_ref_u32_ref_u8(_: (a0: rt.u32, a1: rt.u8) => rt.u32, a: rt.u32, b: rt.u8): rt.u32 { + return rt.u32Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u32_u32_u32_ops_Sub_sub_ref_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u64_ref_u64_u64_ops_Mul_mul_ref_u64_ref_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u64_ref_u8_u64_ops_Shl_shl_ref_u64_ref_u8(_: (a0: rt.u64, a1: rt.u8) => rt.u64, a: rt.u64, b: rt.u8): rt.u64 { + return rt.u64Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u64_u64_u64_ops_Sub_sub_ref_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u8_ref_u8_u8_ops_Mul_mul_ref_u8_ref_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u8_ref_u8_u8_ops_Shl_shl_ref_u8_ref_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_u8_u8_u8_ops_Sub_sub_ref_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_usize_ref_u8_usize_ops_Shl_shl_ref_usize_ref_u8(_: (a0: rt.usize, a1: rt.u8) => rt.usize, a: rt.usize, b: rt.u8): rt.usize { + return rt.usizeShl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_usize_ref_usize_usize_ops_Mul_mul_ref_usize_ref_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return rt.usizeMul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$ref_usize_usize_usize_ops_Sub_sub_ref_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return rt.usizeSub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_i16_u128_ops_Shl_shl_u128_i16(_: (a0: rt.u128, a1: rt.i16) => rt.u128, a: rt.u128, b: rt.i16): rt.u128 { + return rt.u128Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_ref_u128_u128_ops_Add_add_u128_ref_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_Add_add_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_BitAnd_bitand_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128And(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_BitOr_bitor_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Or(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_BitXor_bitxor_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Xor(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_Div_div_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_Mul_mul_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_Rem_rem_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_Shr_shr_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u128_u128_ops_Sub_sub_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { + return rt.u128Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u32_u128_ops_Shl_shl_u128_u32(_: (a0: rt.u128, a1: rt.u32) => rt.u128, a: rt.u128, b: rt.u32): rt.u128 { + return rt.u128Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u128_u32_u128_ops_Shr_shr_u128_u32(_: (a0: rt.u128, a1: rt.u32) => rt.u128, a: rt.u128, b: rt.u32): rt.u128 { + return rt.u128Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_i16_u16_ops_Shl_shl_u16_i16(_: (a0: rt.u16, a1: rt.i16) => rt.u16, a: rt.u16, b: rt.i16): rt.u16 { + return rt.u16Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_ref_u16_u16_ops_Add_add_u16_ref_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return rt.u16Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u128_u16_ops_Shr_shr_u16_u128(_: (a0: rt.u16, a1: rt.u128) => rt.u16, a: rt.u16, b: rt.u128): rt.u16 { + return rt.u16Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u16_u16_ops_Add_add_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return rt.u16Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u16_u16_ops_BitAnd_bitand_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return a & b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u16_u16_ops_BitOr_bitor_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return a | b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u16_u16_ops_BitXor_bitxor_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return a ^ b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u16_u16_ops_Div_div_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return rt.u16Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u16_u16_ops_Mul_mul_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return rt.u16Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u16_u16_ops_Rem_rem_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return rt.u16Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u16_u16_ops_Sub_sub_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { + return rt.u16Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u32_u16_ops_Shl_shl_u16_u32(_: (a0: rt.u16, a1: rt.u32) => rt.u16, a: rt.u16, b: rt.u32): rt.u16 { + return rt.u16Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u16_u32_u16_ops_Shr_shr_u16_u32(_: (a0: rt.u16, a1: rt.u32) => rt.u16, a: rt.u16, b: rt.u32): rt.u16 { + return rt.u16Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_i16_u32_ops_Shl_shl_u32_i16(_: (a0: rt.u32, a1: rt.i16) => rt.u32, a: rt.u32, b: rt.i16): rt.u32 { + return rt.u32Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_ref_u32_u32_ops_Add_add_u32_ref_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u128_u32_ops_Shr_shr_u32_u128(_: (a0: rt.u32, a1: rt.u128) => rt.u32, a: rt.u32, b: rt.u128): rt.u32 { + return rt.u32Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_Add_add_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_BitAnd_bitand_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return (a & b) >>> 0; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_BitOr_bitor_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return (a | b) >>> 0; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_BitXor_bitxor_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return (a ^ b) >>> 0; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_Div_div_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_Mul_mul_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_Rem_rem_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_Shl_shl_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_Shr_shr_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u32_u32_u32_ops_Sub_sub_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { + return rt.u32Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_i16_u64_ops_Shl_shl_u64_i16(_: (a0: rt.u64, a1: rt.i16) => rt.u64, a: rt.u64, b: rt.i16): rt.u64 { + return rt.u64Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_ref_u64_u64_ops_Add_add_u64_ref_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u128_u64_ops_Shr_shr_u64_u128(_: (a0: rt.u64, a1: rt.u128) => rt.u64, a: rt.u64, b: rt.u128): rt.u64 { + return rt.u64Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u32_u64_ops_Shl_shl_u64_u32(_: (a0: rt.u64, a1: rt.u32) => rt.u64, a: rt.u64, b: rt.u32): rt.u64 { + return rt.u64Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u32_u64_ops_Shr_shr_u64_u32(_: (a0: rt.u64, a1: rt.u32) => rt.u64, a: rt.u64, b: rt.u32): rt.u64 { + return rt.u64Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u64_u64_ops_Add_add_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u64_u64_ops_BitAnd_bitand_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64And(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u64_u64_ops_BitOr_bitor_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Or(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u64_u64_ops_BitXor_bitxor_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Xor(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u64_u64_ops_Div_div_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u64_u64_ops_Mul_mul_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u64_u64_ops_Rem_rem_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u64_u64_u64_ops_Sub_sub_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { + return rt.u64Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_i16_u8_ops_Shl_shl_u8_i16(_: (a0: rt.u8, a1: rt.i16) => rt.u8, a: rt.u8, b: rt.i16): rt.u8 { + return rt.u8Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_ref_u8_u8_ops_Add_add_u8_ref_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u128_u8_ops_Shr_shr_u8_u128(_: (a0: rt.u8, a1: rt.u128) => rt.u8, a: rt.u8, b: rt.u128): rt.u8 { + return rt.u8Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u32_u8_ops_Shl_shl_u8_u32(_: (a0: rt.u8, a1: rt.u32) => rt.u8, a: rt.u8, b: rt.u32): rt.u8 { + return rt.u8Shl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u32_u8_ops_Shr_shr_u8_u32(_: (a0: rt.u8, a1: rt.u32) => rt.u8, a: rt.u8, b: rt.u32): rt.u8 { + return rt.u8Shr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u8_u8_ops_Add_add_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Add(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u8_u8_ops_BitAnd_bitand_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return a & b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u8_u8_ops_BitOr_bitor_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return a | b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u8_u8_ops_BitXor_bitxor_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return a ^ b; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u8_u8_ops_Div_div_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Div(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u8_u8_ops_Mul_mul_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Mul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u8_u8_ops_Rem_rem_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Rem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$u8_u8_u8_ops_Sub_sub_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { + return rt.u8Sub(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_i16_usize_ops_Shl_shl_usize_i16(_: (a0: rt.usize, a1: rt.i16) => rt.usize, a: rt.usize, b: rt.i16): rt.usize { + return rt.usizeShl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_ref_usize_usize_ops_Add_add_usize_ref_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return rt.usizeAdd(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_u128_usize_ops_Shr_shr_usize_u128(_: (a0: rt.usize, a1: rt.u128) => rt.usize, a: rt.usize, b: rt.u128): rt.usize { + return rt.usizeShr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_u32_usize_ops_Shl_shl_usize_u32(_: (a0: rt.usize, a1: rt.u32) => rt.usize, a: rt.usize, b: rt.u32): rt.usize { + return rt.usizeShl(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_u32_usize_ops_Shr_shr_usize_u32(_: (a0: rt.usize, a1: rt.u32) => rt.usize, a: rt.usize, b: rt.u32): rt.usize { + return rt.usizeShr(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_usize_usize_ops_Add_add_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return rt.usizeAdd(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_usize_usize_ops_BitAnd_bitand_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return (a & b) >>> 0; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_usize_usize_ops_BitOr_bitor_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return (a | b) >>> 0; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_usize_usize_ops_BitXor_bitxor_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return (a ^ b) >>> 0; +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_usize_usize_ops_Div_div_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return rt.usizeDiv(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_usize_usize_ops_Mul_mul_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return rt.usizeMul(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_usize_usize_ops_Rem_rem_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return rt.usizeRem(a, b); +} + +/** `f(a, b)`, as a generic body calls a function value. */ +export function two$usize_usize_usize_ops_Sub_sub_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { + return rt.usizeSub(a, b); +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.u8; + const _28: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v3: rt.u8): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); + }; + const take: (a0: rt.usize) => rt.u8 = (at: rt.usize): rt.u8 => { + const buf: Uint8Array = Uint8Array.of(0); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.u8FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.u8, rt.u8] = [take(1), take(1 + 1)]; + const a: rt.u8 = _10[0]; + const b: rt.u8 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 1), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.u8Add(a, b); + } else if (_32 === 1) { + v = two$u8_u8_u8_ops_Add_add_u8_u8((a062: rt.u8, a158: rt.u8): rt.u8 => { + return rt.u8Add(a062, a158); + }, a, b); + } else { + v = ((a061: rt.u8, a157: rt.u8): rt.u8 => { + return rt.u8Add(a061, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.u8Sub(a, b); + } else if (_35 === 1) { + v = two$u8_u8_u8_ops_Sub_sub_u8_u8((a060: rt.u8, a156: rt.u8): rt.u8 => { + return rt.u8Sub(a060, a156); + }, a, b); + } else { + v = ((a059: rt.u8, a155: rt.u8): rt.u8 => { + return rt.u8Sub(a059, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.u8Mul(a, b); + } else if (_38 === 1) { + v = two$u8_u8_u8_ops_Mul_mul_u8_u8((a058: rt.u8, a154: rt.u8): rt.u8 => { + return rt.u8Mul(a058, a154); + }, a, b); + } else { + v = ((a057: rt.u8, a153: rt.u8): rt.u8 => { + return rt.u8Mul(a057, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.u8Div(a, b); + } else if (_41 === 1) { + v = two$u8_u8_u8_ops_Div_div_u8_u8((a056: rt.u8, a152: rt.u8): rt.u8 => { + return rt.u8Div(a056, a152); + }, a, b); + } else { + v = ((a055: rt.u8, a151: rt.u8): rt.u8 => { + return rt.u8Div(a055, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.u8Rem(a, b); + } else if (_44 === 1) { + v = two$u8_u8_u8_ops_Rem_rem_u8_u8((a054: rt.u8, a150: rt.u8): rt.u8 => { + return rt.u8Rem(a054, a150); + }, a, b); + } else { + v = ((a053: rt.u8, a149: rt.u8): rt.u8 => { + return rt.u8Rem(a053, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = a & b; + } else if (_47 === 1) { + v = two$u8_u8_u8_ops_BitAnd_bitand_u8_u8((a052: rt.u8, a148: rt.u8): rt.u8 => { + return a052 & a148; + }, a, b); + } else { + v = ((a051: rt.u8, a147: rt.u8): rt.u8 => { + return a051 & a147; + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = a | b; + } else if (_50 === 1) { + v = two$u8_u8_u8_ops_BitOr_bitor_u8_u8((a050: rt.u8, a146: rt.u8): rt.u8 => { + return a050 | a146; + }, a, b); + } else { + v = ((a049: rt.u8, a145: rt.u8): rt.u8 => { + return a049 | a145; + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = a ^ b; + } else if (_53 === 1) { + v = two$u8_u8_u8_ops_BitXor_bitxor_u8_u8((a048: rt.u8, a144: rt.u8): rt.u8 => { + return a048 ^ a144; + }, a, b); + } else { + v = ((a047: rt.u8, a143: rt.u8): rt.u8 => { + return a047 ^ a143; + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.u8Shl(a, n); + } else if (_56 === 1) { + v = two$u8_u32_u8_ops_Shl_shl_u8_u32((a046: rt.u8, a142: rt.u32): rt.u8 => { + return rt.u8Shl(a046, a142); + }, a, n); + } else { + v = ((a045: rt.u8, a141: rt.u32): rt.u8 => { + return rt.u8Shl(a045, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.u8Shr(a, n); + } else if (_59 === 1) { + v = two$u8_u32_u8_ops_Shr_shr_u8_u32((a044: rt.u8, a140: rt.u32): rt.u8 => { + return rt.u8Shr(a044, a140); + }, a, n); + } else { + v = ((a043: rt.u8, a139: rt.u32): rt.u8 => { + return rt.u8Shr(a043, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.u8Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$u8_i16_u8_ops_Shl_shl_u8_i16((a042: rt.u8, a138: rt.i16): rt.u8 => { + return rt.u8Shl(a042, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a041: rt.u8, a137: rt.i16): rt.u8 => { + return rt.u8Shl(a041, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.u8Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$u8_u128_u8_ops_Shr_shr_u8_u128((a040: rt.u8, a136: rt.u128): rt.u8 => { + return rt.u8Shr(a040, a136); + }, a, _74); + } else { + v = ((a039: rt.u8, a135: rt.u128): rt.u8 => { + return rt.u8Shr(a039, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = ~a & 0xff; + } else if (_83 === 1) { + v = one$u8_u8_ops_Not_not_u8((a038: rt.u8): rt.u8 => { + return ~a038 & 0xff; + }, a); + } else { + v = ((a037: rt.u8): rt.u8 => { + return ~a037 & 0xff; + })(a); + } + } else if (_30 === 13) { + const _86 = undefined as rt.u8 | undefined; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.u8 = a; + const _91: rt.u8 = rt.u8Rem(form, 3); + if (_91 === 0) { + x = rt.u8Add(x, b); + } else if (_91 === 1) { + two$mut_u8_u8_unit_ops_AddAssign_add_assign_u8_u8((a036: rt.Place, a134: rt.u8): undefined => { + a036.v = rt.u8Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.u8): undefined => { + a035.v = rt.u8Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.u8 = a; + const _99: rt.u8 = rt.u8Rem(form, 3); + if (_99 === 0) { + x2 = rt.u8Sub(x2, b); + } else if (_99 === 1) { + two$mut_u8_u8_unit_ops_SubAssign_sub_assign_u8_u8((a034: rt.Place, a132: rt.u8): undefined => { + a034.v = rt.u8Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.u8): undefined => { + a033.v = rt.u8Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.u8 = a; + const _107: rt.u8 = rt.u8Rem(form, 3); + if (_107 === 0) { + x3 = rt.u8Mul(x3, b); + } else if (_107 === 1) { + two$mut_u8_u8_unit_ops_MulAssign_mul_assign_u8_u8((a032: rt.Place, a130: rt.u8): undefined => { + a032.v = rt.u8Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.u8): undefined => { + a031.v = rt.u8Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.u8 = a; + const _115: rt.u8 = rt.u8Rem(form, 3); + if (_115 === 0) { + x4 = rt.u8Div(x4, b); + } else if (_115 === 1) { + two$mut_u8_u8_unit_ops_DivAssign_div_assign_u8_u8((a030: rt.Place, a128: rt.u8): undefined => { + a030.v = rt.u8Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.u8): undefined => { + a029.v = rt.u8Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.u8 = a; + const _123: rt.u8 = rt.u8Rem(form, 3); + if (_123 === 0) { + x5 = rt.u8Rem(x5, b); + } else if (_123 === 1) { + two$mut_u8_u8_unit_ops_RemAssign_rem_assign_u8_u8((a028: rt.Place, a126: rt.u8): undefined => { + a028.v = rt.u8Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.u8): undefined => { + a027.v = rt.u8Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.u8 = a; + const _131: rt.u8 = rt.u8Rem(form, 3); + if (_131 === 0) { + x6 = x6 & b; + } else if (_131 === 1) { + two$mut_u8_u8_unit_ops_BitAndAssign_bitand_assign_u8_u8((a026: rt.Place, a124: rt.u8): undefined => { + a026.v = a026.v & a124; + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.u8): undefined => { + a025.v = a025.v & a123; + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.u8 = a; + const _139: rt.u8 = rt.u8Rem(form, 3); + if (_139 === 0) { + x7 = x7 | b; + } else if (_139 === 1) { + two$mut_u8_u8_unit_ops_BitOrAssign_bitor_assign_u8_u8((a024: rt.Place, a122: rt.u8): undefined => { + a024.v = a024.v | a122; + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.u8): undefined => { + a023.v = a023.v | a121; + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.u8 = a; + const _147: rt.u8 = rt.u8Rem(form, 3); + if (_147 === 0) { + x8 = x8 ^ b; + } else if (_147 === 1) { + two$mut_u8_u8_unit_ops_BitXorAssign_bitxor_assign_u8_u8((a022: rt.Place, a120: rt.u8): undefined => { + a022.v = a022.v ^ a120; + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.u8): undefined => { + a021.v = a021.v ^ a119; + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.u8 = a; + const _155: rt.u8 = rt.u8Rem(form, 3); + if (_155 === 0) { + x9 = rt.u8Shl(x9, n); + } else if (_155 === 1) { + two$mut_u8_u32_unit_ops_ShlAssign_shl_assign_u8_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.u8Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.u8Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.u8 = a; + const _163: rt.u8 = rt.u8Rem(form, 3); + if (_163 === 0) { + x10 = rt.u8Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_163 === 1) { + two$mut_u8_i64_unit_ops_ShrAssign_shr_assign_u8_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.u8Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.u8Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _175: rt.u8 = rt.u8Rem(form, 3); + if (_175 === 0) { + v = rt.u8Add(a, b); + } else if (_175 === 1) { + v = two$u8_ref_u8_u8_ops_Add_add_u8_ref_u8((a016: rt.u8, a114: rt.u8): rt.u8 => { + return rt.u8Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.u8, a113: rt.u8): rt.u8 => { + return rt.u8Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _181: rt.u8 = rt.u8Rem(form, 3); + if (_181 === 0) { + v = rt.u8Sub(a, b); + } else if (_181 === 1) { + v = two$ref_u8_u8_u8_ops_Sub_sub_ref_u8_u8((a014: rt.u8, a112: rt.u8): rt.u8 => { + return rt.u8Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.u8, a111: rt.u8): rt.u8 => { + return rt.u8Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _187: rt.u8 = rt.u8Rem(form, 3); + if (_187 === 0) { + v = rt.u8Mul(a, b); + } else if (_187 === 1) { + v = two$ref_u8_ref_u8_u8_ops_Mul_mul_ref_u8_ref_u8((a012: rt.u8, a110: rt.u8): rt.u8 => { + return rt.u8Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.u8, a19: rt.u8): rt.u8 => { + return rt.u8Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _196: rt.u8 = rt.u8Rem(form, 3); + if (_196 === 0) { + v = rt.u8Shl(a, n & 0xff); + } else if (_196 === 1) { + v = two$ref_u8_ref_u8_u8_ops_Shl_shl_ref_u8_ref_u8((a010: rt.u8, a18: rt.u8): rt.u8 => { + return rt.u8Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.u8, a17: rt.u8): rt.u8 => { + return rt.u8Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _208: rt.u8 = rt.u8Rem(form, 3); + if (_208 === 0) { + v = ~a & 0xff; + } else if (_208 === 1) { + v = one$ref_u8_u8_ops_Not_not_ref_u8((a08: rt.u8): rt.u8 => { + return ~a08 & 0xff; + }, a); + } else { + v = ((a07: rt.u8): rt.u8 => { + return ~a07 & 0xff; + })(a); + } + } else if (_30 === 29) { + let x11: rt.u8 = a; + const _216: rt.u8 = rt.u8Rem(form, 3); + if (_216 === 0) { + x11 = rt.u8Add(x11, b); + } else if (_216 === 1) { + two$mut_u8_ref_u8_unit_ops_AddAssign_add_assign_u8_ref_u8((a06: rt.Place, a16: rt.u8): undefined => { + a06.v = rt.u8Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.u8): undefined => { + a05.v = rt.u8Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.u8 = a; + const _227: rt.u8 = rt.u8Rem(form, 3); + if (_227 === 0) { + x12 = rt.u8Div(x12, b); + } else if (_227 === 1) { + two$mut_u8_ref_u8_unit_ops_DivAssign_div_assign_u8_ref_u8((a04: rt.Place, a14: rt.u8): undefined => { + a04.v = rt.u8Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.u8): undefined => { + a03.v = rt.u8Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.u8 = a; + const _238: rt.u8 = rt.u8Rem(form, 3); + if (_238 === 0) { + x13 = rt.u8Shr(x13, n & 0xffff); + } else if (_238 === 1) { + two$mut_u8_ref_u16_unit_ops_ShrAssign_shr_assign_u8_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.u8Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u8Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.u16; + const _28: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v3: rt.u16): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); + }; + const take: (a0: rt.usize) => rt.u16 = (at: rt.usize): rt.u16 => { + const buf: Uint8Array = rt.bytes(2); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.u16FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.u16, rt.u16] = [take(1), take(1 + 2)]; + const a: rt.u16 = _10[0]; + const b: rt.u16 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 2), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.u16Add(a, b); + } else if (_32 === 1) { + v = two$u16_u16_u16_ops_Add_add_u16_u16((a062: rt.u16, a158: rt.u16): rt.u16 => { + return rt.u16Add(a062, a158); + }, a, b); + } else { + v = ((a061: rt.u16, a157: rt.u16): rt.u16 => { + return rt.u16Add(a061, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.u16Sub(a, b); + } else if (_35 === 1) { + v = two$u16_u16_u16_ops_Sub_sub_u16_u16((a060: rt.u16, a156: rt.u16): rt.u16 => { + return rt.u16Sub(a060, a156); + }, a, b); + } else { + v = ((a059: rt.u16, a155: rt.u16): rt.u16 => { + return rt.u16Sub(a059, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.u16Mul(a, b); + } else if (_38 === 1) { + v = two$u16_u16_u16_ops_Mul_mul_u16_u16((a058: rt.u16, a154: rt.u16): rt.u16 => { + return rt.u16Mul(a058, a154); + }, a, b); + } else { + v = ((a057: rt.u16, a153: rt.u16): rt.u16 => { + return rt.u16Mul(a057, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.u16Div(a, b); + } else if (_41 === 1) { + v = two$u16_u16_u16_ops_Div_div_u16_u16((a056: rt.u16, a152: rt.u16): rt.u16 => { + return rt.u16Div(a056, a152); + }, a, b); + } else { + v = ((a055: rt.u16, a151: rt.u16): rt.u16 => { + return rt.u16Div(a055, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.u16Rem(a, b); + } else if (_44 === 1) { + v = two$u16_u16_u16_ops_Rem_rem_u16_u16((a054: rt.u16, a150: rt.u16): rt.u16 => { + return rt.u16Rem(a054, a150); + }, a, b); + } else { + v = ((a053: rt.u16, a149: rt.u16): rt.u16 => { + return rt.u16Rem(a053, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = a & b; + } else if (_47 === 1) { + v = two$u16_u16_u16_ops_BitAnd_bitand_u16_u16((a052: rt.u16, a148: rt.u16): rt.u16 => { + return a052 & a148; + }, a, b); + } else { + v = ((a051: rt.u16, a147: rt.u16): rt.u16 => { + return a051 & a147; + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = a | b; + } else if (_50 === 1) { + v = two$u16_u16_u16_ops_BitOr_bitor_u16_u16((a050: rt.u16, a146: rt.u16): rt.u16 => { + return a050 | a146; + }, a, b); + } else { + v = ((a049: rt.u16, a145: rt.u16): rt.u16 => { + return a049 | a145; + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = a ^ b; + } else if (_53 === 1) { + v = two$u16_u16_u16_ops_BitXor_bitxor_u16_u16((a048: rt.u16, a144: rt.u16): rt.u16 => { + return a048 ^ a144; + }, a, b); + } else { + v = ((a047: rt.u16, a143: rt.u16): rt.u16 => { + return a047 ^ a143; + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.u16Shl(a, n); + } else if (_56 === 1) { + v = two$u16_u32_u16_ops_Shl_shl_u16_u32((a046: rt.u16, a142: rt.u32): rt.u16 => { + return rt.u16Shl(a046, a142); + }, a, n); + } else { + v = ((a045: rt.u16, a141: rt.u32): rt.u16 => { + return rt.u16Shl(a045, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.u16Shr(a, n); + } else if (_59 === 1) { + v = two$u16_u32_u16_ops_Shr_shr_u16_u32((a044: rt.u16, a140: rt.u32): rt.u16 => { + return rt.u16Shr(a044, a140); + }, a, n); + } else { + v = ((a043: rt.u16, a139: rt.u32): rt.u16 => { + return rt.u16Shr(a043, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.u16Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$u16_i16_u16_ops_Shl_shl_u16_i16((a042: rt.u16, a138: rt.i16): rt.u16 => { + return rt.u16Shl(a042, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a041: rt.u16, a137: rt.i16): rt.u16 => { + return rt.u16Shl(a041, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.u16Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$u16_u128_u16_ops_Shr_shr_u16_u128((a040: rt.u16, a136: rt.u128): rt.u16 => { + return rt.u16Shr(a040, a136); + }, a, _74); + } else { + v = ((a039: rt.u16, a135: rt.u128): rt.u16 => { + return rt.u16Shr(a039, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = ~a & 0xffff; + } else if (_83 === 1) { + v = one$u16_u16_ops_Not_not_u16((a038: rt.u16): rt.u16 => { + return ~a038 & 0xffff; + }, a); + } else { + v = ((a037: rt.u16): rt.u16 => { + return ~a037 & 0xffff; + })(a); + } + } else if (_30 === 13) { + const _86 = undefined as rt.u16 | undefined; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.u16 = a; + const _91: rt.u8 = rt.u8Rem(form, 3); + if (_91 === 0) { + x = rt.u16Add(x, b); + } else if (_91 === 1) { + two$mut_u16_u16_unit_ops_AddAssign_add_assign_u16_u16((a036: rt.Place, a134: rt.u16): undefined => { + a036.v = rt.u16Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.u16): undefined => { + a035.v = rt.u16Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.u16 = a; + const _99: rt.u8 = rt.u8Rem(form, 3); + if (_99 === 0) { + x2 = rt.u16Sub(x2, b); + } else if (_99 === 1) { + two$mut_u16_u16_unit_ops_SubAssign_sub_assign_u16_u16((a034: rt.Place, a132: rt.u16): undefined => { + a034.v = rt.u16Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.u16): undefined => { + a033.v = rt.u16Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.u16 = a; + const _107: rt.u8 = rt.u8Rem(form, 3); + if (_107 === 0) { + x3 = rt.u16Mul(x3, b); + } else if (_107 === 1) { + two$mut_u16_u16_unit_ops_MulAssign_mul_assign_u16_u16((a032: rt.Place, a130: rt.u16): undefined => { + a032.v = rt.u16Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.u16): undefined => { + a031.v = rt.u16Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.u16 = a; + const _115: rt.u8 = rt.u8Rem(form, 3); + if (_115 === 0) { + x4 = rt.u16Div(x4, b); + } else if (_115 === 1) { + two$mut_u16_u16_unit_ops_DivAssign_div_assign_u16_u16((a030: rt.Place, a128: rt.u16): undefined => { + a030.v = rt.u16Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.u16): undefined => { + a029.v = rt.u16Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.u16 = a; + const _123: rt.u8 = rt.u8Rem(form, 3); + if (_123 === 0) { + x5 = rt.u16Rem(x5, b); + } else if (_123 === 1) { + two$mut_u16_u16_unit_ops_RemAssign_rem_assign_u16_u16((a028: rt.Place, a126: rt.u16): undefined => { + a028.v = rt.u16Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.u16): undefined => { + a027.v = rt.u16Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.u16 = a; + const _131: rt.u8 = rt.u8Rem(form, 3); + if (_131 === 0) { + x6 = x6 & b; + } else if (_131 === 1) { + two$mut_u16_u16_unit_ops_BitAndAssign_bitand_assign_u16_u16((a026: rt.Place, a124: rt.u16): undefined => { + a026.v = a026.v & a124; + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.u16): undefined => { + a025.v = a025.v & a123; + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.u16 = a; + const _139: rt.u8 = rt.u8Rem(form, 3); + if (_139 === 0) { + x7 = x7 | b; + } else if (_139 === 1) { + two$mut_u16_u16_unit_ops_BitOrAssign_bitor_assign_u16_u16((a024: rt.Place, a122: rt.u16): undefined => { + a024.v = a024.v | a122; + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.u16): undefined => { + a023.v = a023.v | a121; + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.u16 = a; + const _147: rt.u8 = rt.u8Rem(form, 3); + if (_147 === 0) { + x8 = x8 ^ b; + } else if (_147 === 1) { + two$mut_u16_u16_unit_ops_BitXorAssign_bitxor_assign_u16_u16((a022: rt.Place, a120: rt.u16): undefined => { + a022.v = a022.v ^ a120; + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.u16): undefined => { + a021.v = a021.v ^ a119; + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.u16 = a; + const _155: rt.u8 = rt.u8Rem(form, 3); + if (_155 === 0) { + x9 = rt.u16Shl(x9, n); + } else if (_155 === 1) { + two$mut_u16_u32_unit_ops_ShlAssign_shl_assign_u16_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.u16Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.u16Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.u16 = a; + const _163: rt.u8 = rt.u8Rem(form, 3); + if (_163 === 0) { + x10 = rt.u16Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_163 === 1) { + two$mut_u16_i64_unit_ops_ShrAssign_shr_assign_u16_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.u16Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.u16Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _175: rt.u8 = rt.u8Rem(form, 3); + if (_175 === 0) { + v = rt.u16Add(a, b); + } else if (_175 === 1) { + v = two$u16_ref_u16_u16_ops_Add_add_u16_ref_u16((a016: rt.u16, a114: rt.u16): rt.u16 => { + return rt.u16Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.u16, a113: rt.u16): rt.u16 => { + return rt.u16Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _181: rt.u8 = rt.u8Rem(form, 3); + if (_181 === 0) { + v = rt.u16Sub(a, b); + } else if (_181 === 1) { + v = two$ref_u16_u16_u16_ops_Sub_sub_ref_u16_u16((a014: rt.u16, a112: rt.u16): rt.u16 => { + return rt.u16Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.u16, a111: rt.u16): rt.u16 => { + return rt.u16Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _187: rt.u8 = rt.u8Rem(form, 3); + if (_187 === 0) { + v = rt.u16Mul(a, b); + } else if (_187 === 1) { + v = two$ref_u16_ref_u16_u16_ops_Mul_mul_ref_u16_ref_u16((a012: rt.u16, a110: rt.u16): rt.u16 => { + return rt.u16Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.u16, a19: rt.u16): rt.u16 => { + return rt.u16Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _196: rt.u8 = rt.u8Rem(form, 3); + if (_196 === 0) { + v = rt.u16Shl(a, n & 0xff); + } else if (_196 === 1) { + v = two$ref_u16_ref_u8_u16_ops_Shl_shl_ref_u16_ref_u8((a010: rt.u16, a18: rt.u8): rt.u16 => { + return rt.u16Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.u16, a17: rt.u8): rt.u16 => { + return rt.u16Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _208: rt.u8 = rt.u8Rem(form, 3); + if (_208 === 0) { + v = ~a & 0xffff; + } else if (_208 === 1) { + v = one$ref_u16_u16_ops_Not_not_ref_u16((a08: rt.u16): rt.u16 => { + return ~a08 & 0xffff; + }, a); + } else { + v = ((a07: rt.u16): rt.u16 => { + return ~a07 & 0xffff; + })(a); + } + } else if (_30 === 29) { + let x11: rt.u16 = a; + const _216: rt.u8 = rt.u8Rem(form, 3); + if (_216 === 0) { + x11 = rt.u16Add(x11, b); + } else if (_216 === 1) { + two$mut_u16_ref_u16_unit_ops_AddAssign_add_assign_u16_ref_u16((a06: rt.Place, a16: rt.u16): undefined => { + a06.v = rt.u16Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.u16): undefined => { + a05.v = rt.u16Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.u16 = a; + const _227: rt.u8 = rt.u8Rem(form, 3); + if (_227 === 0) { + x12 = rt.u16Div(x12, b); + } else if (_227 === 1) { + two$mut_u16_ref_u16_unit_ops_DivAssign_div_assign_u16_ref_u16((a04: rt.Place, a14: rt.u16): undefined => { + a04.v = rt.u16Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.u16): undefined => { + a03.v = rt.u16Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.u16 = a; + const _238: rt.u8 = rt.u8Rem(form, 3); + if (_238 === 0) { + x13 = rt.u16Shr(x13, n & 0xffff); + } else if (_238 === 1) { + two$mut_u16_ref_u16_unit_ops_ShrAssign_shr_assign_u16_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.u16Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u16Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.u32; + const _28: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v3: rt.u32): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); + }; + const take: (a0: rt.usize) => rt.u32 = (at: rt.usize): rt.u32 => { + const buf: Uint8Array = rt.bytes(4); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.u32FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.u32, rt.u32] = [take(1), take(1 + 4)]; + const a: rt.u32 = _10[0]; + const b: rt.u32 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 4), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.u32Add(a, b); + } else if (_32 === 1) { + v = two$u32_u32_u32_ops_Add_add_u32_u32((a062: rt.u32, a158: rt.u32): rt.u32 => { + return rt.u32Add(a062, a158); + }, a, b); + } else { + v = ((a061: rt.u32, a157: rt.u32): rt.u32 => { + return rt.u32Add(a061, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.u32Sub(a, b); + } else if (_35 === 1) { + v = two$u32_u32_u32_ops_Sub_sub_u32_u32((a060: rt.u32, a156: rt.u32): rt.u32 => { + return rt.u32Sub(a060, a156); + }, a, b); + } else { + v = ((a059: rt.u32, a155: rt.u32): rt.u32 => { + return rt.u32Sub(a059, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.u32Mul(a, b); + } else if (_38 === 1) { + v = two$u32_u32_u32_ops_Mul_mul_u32_u32((a058: rt.u32, a154: rt.u32): rt.u32 => { + return rt.u32Mul(a058, a154); + }, a, b); + } else { + v = ((a057: rt.u32, a153: rt.u32): rt.u32 => { + return rt.u32Mul(a057, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.u32Div(a, b); + } else if (_41 === 1) { + v = two$u32_u32_u32_ops_Div_div_u32_u32((a056: rt.u32, a152: rt.u32): rt.u32 => { + return rt.u32Div(a056, a152); + }, a, b); + } else { + v = ((a055: rt.u32, a151: rt.u32): rt.u32 => { + return rt.u32Div(a055, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.u32Rem(a, b); + } else if (_44 === 1) { + v = two$u32_u32_u32_ops_Rem_rem_u32_u32((a054: rt.u32, a150: rt.u32): rt.u32 => { + return rt.u32Rem(a054, a150); + }, a, b); + } else { + v = ((a053: rt.u32, a149: rt.u32): rt.u32 => { + return rt.u32Rem(a053, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = (a & b) >>> 0; + } else if (_47 === 1) { + v = two$u32_u32_u32_ops_BitAnd_bitand_u32_u32((a052: rt.u32, a148: rt.u32): rt.u32 => { + return (a052 & a148) >>> 0; + }, a, b); + } else { + v = ((a051: rt.u32, a147: rt.u32): rt.u32 => { + return (a051 & a147) >>> 0; + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = (a | b) >>> 0; + } else if (_50 === 1) { + v = two$u32_u32_u32_ops_BitOr_bitor_u32_u32((a050: rt.u32, a146: rt.u32): rt.u32 => { + return (a050 | a146) >>> 0; + }, a, b); + } else { + v = ((a049: rt.u32, a145: rt.u32): rt.u32 => { + return (a049 | a145) >>> 0; + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = (a ^ b) >>> 0; + } else if (_53 === 1) { + v = two$u32_u32_u32_ops_BitXor_bitxor_u32_u32((a048: rt.u32, a144: rt.u32): rt.u32 => { + return (a048 ^ a144) >>> 0; + }, a, b); + } else { + v = ((a047: rt.u32, a143: rt.u32): rt.u32 => { + return (a047 ^ a143) >>> 0; + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.u32Shl(a, n); + } else if (_56 === 1) { + v = two$u32_u32_u32_ops_Shl_shl_u32_u32((a046: rt.u32, a142: rt.u32): rt.u32 => { + return rt.u32Shl(a046, a142); + }, a, n); + } else { + v = ((a045: rt.u32, a141: rt.u32): rt.u32 => { + return rt.u32Shl(a045, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.u32Shr(a, n); + } else if (_59 === 1) { + v = two$u32_u32_u32_ops_Shr_shr_u32_u32((a044: rt.u32, a140: rt.u32): rt.u32 => { + return rt.u32Shr(a044, a140); + }, a, n); + } else { + v = ((a043: rt.u32, a139: rt.u32): rt.u32 => { + return rt.u32Shr(a043, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.u32Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$u32_i16_u32_ops_Shl_shl_u32_i16((a042: rt.u32, a138: rt.i16): rt.u32 => { + return rt.u32Shl(a042, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a041: rt.u32, a137: rt.i16): rt.u32 => { + return rt.u32Shl(a041, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.u32Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$u32_u128_u32_ops_Shr_shr_u32_u128((a040: rt.u32, a136: rt.u128): rt.u32 => { + return rt.u32Shr(a040, a136); + }, a, _74); + } else { + v = ((a039: rt.u32, a135: rt.u128): rt.u32 => { + return rt.u32Shr(a039, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = ~a >>> 0; + } else if (_83 === 1) { + v = one$u32_u32_ops_Not_not_u32((a038: rt.u32): rt.u32 => { + return ~a038 >>> 0; + }, a); + } else { + v = ((a037: rt.u32): rt.u32 => { + return ~a037 >>> 0; + })(a); + } + } else if (_30 === 13) { + const _86 = undefined as rt.u32 | undefined; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.u32 = a; + const _91: rt.u8 = rt.u8Rem(form, 3); + if (_91 === 0) { + x = rt.u32Add(x, b); + } else if (_91 === 1) { + two$mut_u32_u32_unit_ops_AddAssign_add_assign_u32_u32((a036: rt.Place, a134: rt.u32): undefined => { + a036.v = rt.u32Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.u32): undefined => { + a035.v = rt.u32Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.u32 = a; + const _99: rt.u8 = rt.u8Rem(form, 3); + if (_99 === 0) { + x2 = rt.u32Sub(x2, b); + } else if (_99 === 1) { + two$mut_u32_u32_unit_ops_SubAssign_sub_assign_u32_u32((a034: rt.Place, a132: rt.u32): undefined => { + a034.v = rt.u32Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.u32): undefined => { + a033.v = rt.u32Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.u32 = a; + const _107: rt.u8 = rt.u8Rem(form, 3); + if (_107 === 0) { + x3 = rt.u32Mul(x3, b); + } else if (_107 === 1) { + two$mut_u32_u32_unit_ops_MulAssign_mul_assign_u32_u32((a032: rt.Place, a130: rt.u32): undefined => { + a032.v = rt.u32Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.u32): undefined => { + a031.v = rt.u32Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.u32 = a; + const _115: rt.u8 = rt.u8Rem(form, 3); + if (_115 === 0) { + x4 = rt.u32Div(x4, b); + } else if (_115 === 1) { + two$mut_u32_u32_unit_ops_DivAssign_div_assign_u32_u32((a030: rt.Place, a128: rt.u32): undefined => { + a030.v = rt.u32Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.u32): undefined => { + a029.v = rt.u32Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.u32 = a; + const _123: rt.u8 = rt.u8Rem(form, 3); + if (_123 === 0) { + x5 = rt.u32Rem(x5, b); + } else if (_123 === 1) { + two$mut_u32_u32_unit_ops_RemAssign_rem_assign_u32_u32((a028: rt.Place, a126: rt.u32): undefined => { + a028.v = rt.u32Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.u32): undefined => { + a027.v = rt.u32Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.u32 = a; + const _131: rt.u8 = rt.u8Rem(form, 3); + if (_131 === 0) { + x6 = (x6 & b) >>> 0; + } else if (_131 === 1) { + two$mut_u32_u32_unit_ops_BitAndAssign_bitand_assign_u32_u32((a026: rt.Place, a124: rt.u32): undefined => { + a026.v = (a026.v & a124) >>> 0; + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.u32): undefined => { + a025.v = (a025.v & a123) >>> 0; + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.u32 = a; + const _139: rt.u8 = rt.u8Rem(form, 3); + if (_139 === 0) { + x7 = (x7 | b) >>> 0; + } else if (_139 === 1) { + two$mut_u32_u32_unit_ops_BitOrAssign_bitor_assign_u32_u32((a024: rt.Place, a122: rt.u32): undefined => { + a024.v = (a024.v | a122) >>> 0; + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.u32): undefined => { + a023.v = (a023.v | a121) >>> 0; + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.u32 = a; + const _147: rt.u8 = rt.u8Rem(form, 3); + if (_147 === 0) { + x8 = (x8 ^ b) >>> 0; + } else if (_147 === 1) { + two$mut_u32_u32_unit_ops_BitXorAssign_bitxor_assign_u32_u32((a022: rt.Place, a120: rt.u32): undefined => { + a022.v = (a022.v ^ a120) >>> 0; + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.u32): undefined => { + a021.v = (a021.v ^ a119) >>> 0; + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.u32 = a; + const _155: rt.u8 = rt.u8Rem(form, 3); + if (_155 === 0) { + x9 = rt.u32Shl(x9, n); + } else if (_155 === 1) { + two$mut_u32_u32_unit_ops_ShlAssign_shl_assign_u32_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.u32Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.u32Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.u32 = a; + const _163: rt.u8 = rt.u8Rem(form, 3); + if (_163 === 0) { + x10 = rt.u32Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_163 === 1) { + two$mut_u32_i64_unit_ops_ShrAssign_shr_assign_u32_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.u32Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.u32Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _175: rt.u8 = rt.u8Rem(form, 3); + if (_175 === 0) { + v = rt.u32Add(a, b); + } else if (_175 === 1) { + v = two$u32_ref_u32_u32_ops_Add_add_u32_ref_u32((a016: rt.u32, a114: rt.u32): rt.u32 => { + return rt.u32Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.u32, a113: rt.u32): rt.u32 => { + return rt.u32Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _181: rt.u8 = rt.u8Rem(form, 3); + if (_181 === 0) { + v = rt.u32Sub(a, b); + } else if (_181 === 1) { + v = two$ref_u32_u32_u32_ops_Sub_sub_ref_u32_u32((a014: rt.u32, a112: rt.u32): rt.u32 => { + return rt.u32Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.u32, a111: rt.u32): rt.u32 => { + return rt.u32Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _187: rt.u8 = rt.u8Rem(form, 3); + if (_187 === 0) { + v = rt.u32Mul(a, b); + } else if (_187 === 1) { + v = two$ref_u32_ref_u32_u32_ops_Mul_mul_ref_u32_ref_u32((a012: rt.u32, a110: rt.u32): rt.u32 => { + return rt.u32Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.u32, a19: rt.u32): rt.u32 => { + return rt.u32Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _196: rt.u8 = rt.u8Rem(form, 3); + if (_196 === 0) { + v = rt.u32Shl(a, n & 0xff); + } else if (_196 === 1) { + v = two$ref_u32_ref_u8_u32_ops_Shl_shl_ref_u32_ref_u8((a010: rt.u32, a18: rt.u8): rt.u32 => { + return rt.u32Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.u32, a17: rt.u8): rt.u32 => { + return rt.u32Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _208: rt.u8 = rt.u8Rem(form, 3); + if (_208 === 0) { + v = ~a >>> 0; + } else if (_208 === 1) { + v = one$ref_u32_u32_ops_Not_not_ref_u32((a08: rt.u32): rt.u32 => { + return ~a08 >>> 0; + }, a); + } else { + v = ((a07: rt.u32): rt.u32 => { + return ~a07 >>> 0; + })(a); + } + } else if (_30 === 29) { + let x11: rt.u32 = a; + const _216: rt.u8 = rt.u8Rem(form, 3); + if (_216 === 0) { + x11 = rt.u32Add(x11, b); + } else if (_216 === 1) { + two$mut_u32_ref_u32_unit_ops_AddAssign_add_assign_u32_ref_u32((a06: rt.Place, a16: rt.u32): undefined => { + a06.v = rt.u32Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.u32): undefined => { + a05.v = rt.u32Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.u32 = a; + const _227: rt.u8 = rt.u8Rem(form, 3); + if (_227 === 0) { + x12 = rt.u32Div(x12, b); + } else if (_227 === 1) { + two$mut_u32_ref_u32_unit_ops_DivAssign_div_assign_u32_ref_u32((a04: rt.Place, a14: rt.u32): undefined => { + a04.v = rt.u32Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.u32): undefined => { + a03.v = rt.u32Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.u32 = a; + const _238: rt.u8 = rt.u8Rem(form, 3); + if (_238 === 0) { + x13 = rt.u32Shr(x13, n & 0xffff); + } else if (_238 === 1) { + two$mut_u32_ref_u16_unit_ops_ShrAssign_shr_assign_u32_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.u32Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u32Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.u64; + const _28: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v3: rt.u64): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(v3)))); + }; + const take: (a0: rt.usize) => rt.u64 = (at: rt.usize): rt.u64 => { + const buf: Uint8Array = rt.bytes(8); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.u64FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.u64, rt.u64] = [take(1), take(1 + 8)]; + const a: rt.u64 = _10[0]; + const b: rt.u64 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 8), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.u64Add(a, b); + } else if (_32 === 1) { + v = two$u64_u64_u64_ops_Add_add_u64_u64((a062: rt.u64, a158: rt.u64): rt.u64 => { + return rt.u64Add(a062, a158); + }, a, b); + } else { + v = ((a061: rt.u64, a157: rt.u64): rt.u64 => { + return rt.u64Add(a061, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.u64Sub(a, b); + } else if (_35 === 1) { + v = two$u64_u64_u64_ops_Sub_sub_u64_u64((a060: rt.u64, a156: rt.u64): rt.u64 => { + return rt.u64Sub(a060, a156); + }, a, b); + } else { + v = ((a059: rt.u64, a155: rt.u64): rt.u64 => { + return rt.u64Sub(a059, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.u64Mul(a, b); + } else if (_38 === 1) { + v = two$u64_u64_u64_ops_Mul_mul_u64_u64((a058: rt.u64, a154: rt.u64): rt.u64 => { + return rt.u64Mul(a058, a154); + }, a, b); + } else { + v = ((a057: rt.u64, a153: rt.u64): rt.u64 => { + return rt.u64Mul(a057, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.u64Div(a, b); + } else if (_41 === 1) { + v = two$u64_u64_u64_ops_Div_div_u64_u64((a056: rt.u64, a152: rt.u64): rt.u64 => { + return rt.u64Div(a056, a152); + }, a, b); + } else { + v = ((a055: rt.u64, a151: rt.u64): rt.u64 => { + return rt.u64Div(a055, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.u64Rem(a, b); + } else if (_44 === 1) { + v = two$u64_u64_u64_ops_Rem_rem_u64_u64((a054: rt.u64, a150: rt.u64): rt.u64 => { + return rt.u64Rem(a054, a150); + }, a, b); + } else { + v = ((a053: rt.u64, a149: rt.u64): rt.u64 => { + return rt.u64Rem(a053, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = rt.u64And(a, b); + } else if (_47 === 1) { + v = two$u64_u64_u64_ops_BitAnd_bitand_u64_u64((a052: rt.u64, a148: rt.u64): rt.u64 => { + return rt.u64And(a052, a148); + }, a, b); + } else { + v = ((a051: rt.u64, a147: rt.u64): rt.u64 => { + return rt.u64And(a051, a147); + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = rt.u64Or(a, b); + } else if (_50 === 1) { + v = two$u64_u64_u64_ops_BitOr_bitor_u64_u64((a050: rt.u64, a146: rt.u64): rt.u64 => { + return rt.u64Or(a050, a146); + }, a, b); + } else { + v = ((a049: rt.u64, a145: rt.u64): rt.u64 => { + return rt.u64Or(a049, a145); + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = rt.u64Xor(a, b); + } else if (_53 === 1) { + v = two$u64_u64_u64_ops_BitXor_bitxor_u64_u64((a048: rt.u64, a144: rt.u64): rt.u64 => { + return rt.u64Xor(a048, a144); + }, a, b); + } else { + v = ((a047: rt.u64, a143: rt.u64): rt.u64 => { + return rt.u64Xor(a047, a143); + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.u64Shl(a, n); + } else if (_56 === 1) { + v = two$u64_u32_u64_ops_Shl_shl_u64_u32((a046: rt.u64, a142: rt.u32): rt.u64 => { + return rt.u64Shl(a046, a142); + }, a, n); + } else { + v = ((a045: rt.u64, a141: rt.u32): rt.u64 => { + return rt.u64Shl(a045, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.u64Shr(a, n); + } else if (_59 === 1) { + v = two$u64_u32_u64_ops_Shr_shr_u64_u32((a044: rt.u64, a140: rt.u32): rt.u64 => { + return rt.u64Shr(a044, a140); + }, a, n); + } else { + v = ((a043: rt.u64, a139: rt.u32): rt.u64 => { + return rt.u64Shr(a043, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.u64Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$u64_i16_u64_ops_Shl_shl_u64_i16((a042: rt.u64, a138: rt.i16): rt.u64 => { + return rt.u64Shl(a042, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a041: rt.u64, a137: rt.i16): rt.u64 => { + return rt.u64Shl(a041, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.u64Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$u64_u128_u64_ops_Shr_shr_u64_u128((a040: rt.u64, a136: rt.u128): rt.u64 => { + return rt.u64Shr(a040, a136); + }, a, _74); + } else { + v = ((a039: rt.u64, a135: rt.u128): rt.u64 => { + return rt.u64Shr(a039, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = rt.u64Not(a); + } else if (_83 === 1) { + v = one$u64_u64_ops_Not_not_u64((a038: rt.u64): rt.u64 => { + return rt.u64Not(a038); + }, a); + } else { + v = ((a037: rt.u64): rt.u64 => { + return rt.u64Not(a037); + })(a); + } + } else if (_30 === 13) { + const _86 = undefined as rt.u64 | undefined; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.u64 = a; + const _91: rt.u8 = rt.u8Rem(form, 3); + if (_91 === 0) { + x = rt.u64Add(x, b); + } else if (_91 === 1) { + two$mut_u64_u64_unit_ops_AddAssign_add_assign_u64_u64((a036: rt.Place, a134: rt.u64): undefined => { + a036.v = rt.u64Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.u64): undefined => { + a035.v = rt.u64Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.u64 = a; + const _99: rt.u8 = rt.u8Rem(form, 3); + if (_99 === 0) { + x2 = rt.u64Sub(x2, b); + } else if (_99 === 1) { + two$mut_u64_u64_unit_ops_SubAssign_sub_assign_u64_u64((a034: rt.Place, a132: rt.u64): undefined => { + a034.v = rt.u64Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.u64): undefined => { + a033.v = rt.u64Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.u64 = a; + const _107: rt.u8 = rt.u8Rem(form, 3); + if (_107 === 0) { + x3 = rt.u64Mul(x3, b); + } else if (_107 === 1) { + two$mut_u64_u64_unit_ops_MulAssign_mul_assign_u64_u64((a032: rt.Place, a130: rt.u64): undefined => { + a032.v = rt.u64Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.u64): undefined => { + a031.v = rt.u64Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.u64 = a; + const _115: rt.u8 = rt.u8Rem(form, 3); + if (_115 === 0) { + x4 = rt.u64Div(x4, b); + } else if (_115 === 1) { + two$mut_u64_u64_unit_ops_DivAssign_div_assign_u64_u64((a030: rt.Place, a128: rt.u64): undefined => { + a030.v = rt.u64Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.u64): undefined => { + a029.v = rt.u64Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.u64 = a; + const _123: rt.u8 = rt.u8Rem(form, 3); + if (_123 === 0) { + x5 = rt.u64Rem(x5, b); + } else if (_123 === 1) { + two$mut_u64_u64_unit_ops_RemAssign_rem_assign_u64_u64((a028: rt.Place, a126: rt.u64): undefined => { + a028.v = rt.u64Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.u64): undefined => { + a027.v = rt.u64Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.u64 = a; + const _131: rt.u8 = rt.u8Rem(form, 3); + if (_131 === 0) { + x6 = rt.u64And(x6, b); + } else if (_131 === 1) { + two$mut_u64_u64_unit_ops_BitAndAssign_bitand_assign_u64_u64((a026: rt.Place, a124: rt.u64): undefined => { + a026.v = rt.u64And(a026.v, a124); + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.u64): undefined => { + a025.v = rt.u64And(a025.v, a123); + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.u64 = a; + const _139: rt.u8 = rt.u8Rem(form, 3); + if (_139 === 0) { + x7 = rt.u64Or(x7, b); + } else if (_139 === 1) { + two$mut_u64_u64_unit_ops_BitOrAssign_bitor_assign_u64_u64((a024: rt.Place, a122: rt.u64): undefined => { + a024.v = rt.u64Or(a024.v, a122); + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.u64): undefined => { + a023.v = rt.u64Or(a023.v, a121); + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.u64 = a; + const _147: rt.u8 = rt.u8Rem(form, 3); + if (_147 === 0) { + x8 = rt.u64Xor(x8, b); + } else if (_147 === 1) { + two$mut_u64_u64_unit_ops_BitXorAssign_bitxor_assign_u64_u64((a022: rt.Place, a120: rt.u64): undefined => { + a022.v = rt.u64Xor(a022.v, a120); + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.u64): undefined => { + a021.v = rt.u64Xor(a021.v, a119); + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.u64 = a; + const _155: rt.u8 = rt.u8Rem(form, 3); + if (_155 === 0) { + x9 = rt.u64Shl(x9, n); + } else if (_155 === 1) { + two$mut_u64_u32_unit_ops_ShlAssign_shl_assign_u64_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.u64Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.u64Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.u64 = a; + const _163: rt.u8 = rt.u8Rem(form, 3); + if (_163 === 0) { + x10 = rt.u64Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_163 === 1) { + two$mut_u64_i64_unit_ops_ShrAssign_shr_assign_u64_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.u64Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.u64Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _175: rt.u8 = rt.u8Rem(form, 3); + if (_175 === 0) { + v = rt.u64Add(a, b); + } else if (_175 === 1) { + v = two$u64_ref_u64_u64_ops_Add_add_u64_ref_u64((a016: rt.u64, a114: rt.u64): rt.u64 => { + return rt.u64Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.u64, a113: rt.u64): rt.u64 => { + return rt.u64Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _181: rt.u8 = rt.u8Rem(form, 3); + if (_181 === 0) { + v = rt.u64Sub(a, b); + } else if (_181 === 1) { + v = two$ref_u64_u64_u64_ops_Sub_sub_ref_u64_u64((a014: rt.u64, a112: rt.u64): rt.u64 => { + return rt.u64Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.u64, a111: rt.u64): rt.u64 => { + return rt.u64Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _187: rt.u8 = rt.u8Rem(form, 3); + if (_187 === 0) { + v = rt.u64Mul(a, b); + } else if (_187 === 1) { + v = two$ref_u64_ref_u64_u64_ops_Mul_mul_ref_u64_ref_u64((a012: rt.u64, a110: rt.u64): rt.u64 => { + return rt.u64Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.u64, a19: rt.u64): rt.u64 => { + return rt.u64Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _196: rt.u8 = rt.u8Rem(form, 3); + if (_196 === 0) { + v = rt.u64Shl(a, n & 0xff); + } else if (_196 === 1) { + v = two$ref_u64_ref_u8_u64_ops_Shl_shl_ref_u64_ref_u8((a010: rt.u64, a18: rt.u8): rt.u64 => { + return rt.u64Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.u64, a17: rt.u8): rt.u64 => { + return rt.u64Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _208: rt.u8 = rt.u8Rem(form, 3); + if (_208 === 0) { + v = rt.u64Not(a); + } else if (_208 === 1) { + v = one$ref_u64_u64_ops_Not_not_ref_u64((a08: rt.u64): rt.u64 => { + return rt.u64Not(a08); + }, a); + } else { + v = ((a07: rt.u64): rt.u64 => { + return rt.u64Not(a07); + })(a); + } + } else if (_30 === 29) { + let x11: rt.u64 = a; + const _216: rt.u8 = rt.u8Rem(form, 3); + if (_216 === 0) { + x11 = rt.u64Add(x11, b); + } else if (_216 === 1) { + two$mut_u64_ref_u64_unit_ops_AddAssign_add_assign_u64_ref_u64((a06: rt.Place, a16: rt.u64): undefined => { + a06.v = rt.u64Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.u64): undefined => { + a05.v = rt.u64Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.u64 = a; + const _227: rt.u8 = rt.u8Rem(form, 3); + if (_227 === 0) { + x12 = rt.u64Div(x12, b); + } else if (_227 === 1) { + two$mut_u64_ref_u64_unit_ops_DivAssign_div_assign_u64_ref_u64((a04: rt.Place, a14: rt.u64): undefined => { + a04.v = rt.u64Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.u64): undefined => { + a03.v = rt.u64Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.u64 = a; + const _238: rt.u8 = rt.u8Rem(form, 3); + if (_238 === 0) { + x13 = rt.u64Shr(x13, n & 0xffff); + } else if (_238 === 1) { + two$mut_u64_ref_u16_unit_ops_ShrAssign_shr_assign_u64_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.u64Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u64Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.u128; + const _28: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v3: rt.u128): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3))); + }; + const take: (a0: rt.usize) => rt.u128 = (at: rt.usize): rt.u128 => { + const buf: Uint8Array = rt.bytes(16); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.u128FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.u128, rt.u128] = [take(1), take(1 + 16)]; + const a: rt.u128 = _10[0]; + const b: rt.u128 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 16), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.u128Add(a, b); + } else if (_32 === 1) { + v = two$u128_u128_u128_ops_Add_add_u128_u128((a062: rt.u128, a158: rt.u128): rt.u128 => { + return rt.u128Add(a062, a158); + }, a, b); + } else { + v = ((a061: rt.u128, a157: rt.u128): rt.u128 => { + return rt.u128Add(a061, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.u128Sub(a, b); + } else if (_35 === 1) { + v = two$u128_u128_u128_ops_Sub_sub_u128_u128((a060: rt.u128, a156: rt.u128): rt.u128 => { + return rt.u128Sub(a060, a156); + }, a, b); + } else { + v = ((a059: rt.u128, a155: rt.u128): rt.u128 => { + return rt.u128Sub(a059, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.u128Mul(a, b); + } else if (_38 === 1) { + v = two$u128_u128_u128_ops_Mul_mul_u128_u128((a058: rt.u128, a154: rt.u128): rt.u128 => { + return rt.u128Mul(a058, a154); + }, a, b); + } else { + v = ((a057: rt.u128, a153: rt.u128): rt.u128 => { + return rt.u128Mul(a057, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.u128Div(a, b); + } else if (_41 === 1) { + v = two$u128_u128_u128_ops_Div_div_u128_u128((a056: rt.u128, a152: rt.u128): rt.u128 => { + return rt.u128Div(a056, a152); + }, a, b); + } else { + v = ((a055: rt.u128, a151: rt.u128): rt.u128 => { + return rt.u128Div(a055, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.u128Rem(a, b); + } else if (_44 === 1) { + v = two$u128_u128_u128_ops_Rem_rem_u128_u128((a054: rt.u128, a150: rt.u128): rt.u128 => { + return rt.u128Rem(a054, a150); + }, a, b); + } else { + v = ((a053: rt.u128, a149: rt.u128): rt.u128 => { + return rt.u128Rem(a053, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = rt.u128And(a, b); + } else if (_47 === 1) { + v = two$u128_u128_u128_ops_BitAnd_bitand_u128_u128((a052: rt.u128, a148: rt.u128): rt.u128 => { + return rt.u128And(a052, a148); + }, a, b); + } else { + v = ((a051: rt.u128, a147: rt.u128): rt.u128 => { + return rt.u128And(a051, a147); + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = rt.u128Or(a, b); + } else if (_50 === 1) { + v = two$u128_u128_u128_ops_BitOr_bitor_u128_u128((a050: rt.u128, a146: rt.u128): rt.u128 => { + return rt.u128Or(a050, a146); + }, a, b); + } else { + v = ((a049: rt.u128, a145: rt.u128): rt.u128 => { + return rt.u128Or(a049, a145); + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = rt.u128Xor(a, b); + } else if (_53 === 1) { + v = two$u128_u128_u128_ops_BitXor_bitxor_u128_u128((a048: rt.u128, a144: rt.u128): rt.u128 => { + return rt.u128Xor(a048, a144); + }, a, b); + } else { + v = ((a047: rt.u128, a143: rt.u128): rt.u128 => { + return rt.u128Xor(a047, a143); + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.u128Shl(a, n); + } else if (_56 === 1) { + v = two$u128_u32_u128_ops_Shl_shl_u128_u32((a046: rt.u128, a142: rt.u32): rt.u128 => { + return rt.u128Shl(a046, a142); + }, a, n); + } else { + v = ((a045: rt.u128, a141: rt.u32): rt.u128 => { + return rt.u128Shl(a045, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.u128Shr(a, n); + } else if (_59 === 1) { + v = two$u128_u32_u128_ops_Shr_shr_u128_u32((a044: rt.u128, a140: rt.u32): rt.u128 => { + return rt.u128Shr(a044, a140); + }, a, n); + } else { + v = ((a043: rt.u128, a139: rt.u32): rt.u128 => { + return rt.u128Shr(a043, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.u128Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$u128_i16_u128_ops_Shl_shl_u128_i16((a042: rt.u128, a138: rt.i16): rt.u128 => { + return rt.u128Shl(a042, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a041: rt.u128, a137: rt.i16): rt.u128 => { + return rt.u128Shl(a041, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.u128Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$u128_u128_u128_ops_Shr_shr_u128_u128((a040: rt.u128, a136: rt.u128): rt.u128 => { + return rt.u128Shr(a040, a136); + }, a, _74); + } else { + v = ((a039: rt.u128, a135: rt.u128): rt.u128 => { + return rt.u128Shr(a039, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = rt.u128Not(a); + } else if (_83 === 1) { + v = one$u128_u128_ops_Not_not_u128((a038: rt.u128): rt.u128 => { + return rt.u128Not(a038); + }, a); + } else { + v = ((a037: rt.u128): rt.u128 => { + return rt.u128Not(a037); + })(a); + } + } else if (_30 === 13) { + const _86 = undefined as rt.u128 | undefined; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.u128 = a; + const _91: rt.u8 = rt.u8Rem(form, 3); + if (_91 === 0) { + x = rt.u128Add(x, b); + } else if (_91 === 1) { + two$mut_u128_u128_unit_ops_AddAssign_add_assign_u128_u128((a036: rt.Place, a134: rt.u128): undefined => { + a036.v = rt.u128Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.u128): undefined => { + a035.v = rt.u128Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.u128 = a; + const _99: rt.u8 = rt.u8Rem(form, 3); + if (_99 === 0) { + x2 = rt.u128Sub(x2, b); + } else if (_99 === 1) { + two$mut_u128_u128_unit_ops_SubAssign_sub_assign_u128_u128((a034: rt.Place, a132: rt.u128): undefined => { + a034.v = rt.u128Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.u128): undefined => { + a033.v = rt.u128Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.u128 = a; + const _107: rt.u8 = rt.u8Rem(form, 3); + if (_107 === 0) { + x3 = rt.u128Mul(x3, b); + } else if (_107 === 1) { + two$mut_u128_u128_unit_ops_MulAssign_mul_assign_u128_u128((a032: rt.Place, a130: rt.u128): undefined => { + a032.v = rt.u128Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.u128): undefined => { + a031.v = rt.u128Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.u128 = a; + const _115: rt.u8 = rt.u8Rem(form, 3); + if (_115 === 0) { + x4 = rt.u128Div(x4, b); + } else if (_115 === 1) { + two$mut_u128_u128_unit_ops_DivAssign_div_assign_u128_u128((a030: rt.Place, a128: rt.u128): undefined => { + a030.v = rt.u128Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.u128): undefined => { + a029.v = rt.u128Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.u128 = a; + const _123: rt.u8 = rt.u8Rem(form, 3); + if (_123 === 0) { + x5 = rt.u128Rem(x5, b); + } else if (_123 === 1) { + two$mut_u128_u128_unit_ops_RemAssign_rem_assign_u128_u128((a028: rt.Place, a126: rt.u128): undefined => { + a028.v = rt.u128Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.u128): undefined => { + a027.v = rt.u128Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.u128 = a; + const _131: rt.u8 = rt.u8Rem(form, 3); + if (_131 === 0) { + x6 = rt.u128And(x6, b); + } else if (_131 === 1) { + two$mut_u128_u128_unit_ops_BitAndAssign_bitand_assign_u128_u128((a026: rt.Place, a124: rt.u128): undefined => { + a026.v = rt.u128And(a026.v, a124); + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.u128): undefined => { + a025.v = rt.u128And(a025.v, a123); + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.u128 = a; + const _139: rt.u8 = rt.u8Rem(form, 3); + if (_139 === 0) { + x7 = rt.u128Or(x7, b); + } else if (_139 === 1) { + two$mut_u128_u128_unit_ops_BitOrAssign_bitor_assign_u128_u128((a024: rt.Place, a122: rt.u128): undefined => { + a024.v = rt.u128Or(a024.v, a122); + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.u128): undefined => { + a023.v = rt.u128Or(a023.v, a121); + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.u128 = a; + const _147: rt.u8 = rt.u8Rem(form, 3); + if (_147 === 0) { + x8 = rt.u128Xor(x8, b); + } else if (_147 === 1) { + two$mut_u128_u128_unit_ops_BitXorAssign_bitxor_assign_u128_u128((a022: rt.Place, a120: rt.u128): undefined => { + a022.v = rt.u128Xor(a022.v, a120); + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.u128): undefined => { + a021.v = rt.u128Xor(a021.v, a119); + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.u128 = a; + const _155: rt.u8 = rt.u8Rem(form, 3); + if (_155 === 0) { + x9 = rt.u128Shl(x9, n); + } else if (_155 === 1) { + two$mut_u128_u32_unit_ops_ShlAssign_shl_assign_u128_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.u128Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.u128Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.u128 = a; + const _163: rt.u8 = rt.u8Rem(form, 3); + if (_163 === 0) { + x10 = rt.u128Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_163 === 1) { + two$mut_u128_i64_unit_ops_ShrAssign_shr_assign_u128_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.u128Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.u128Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _175: rt.u8 = rt.u8Rem(form, 3); + if (_175 === 0) { + v = rt.u128Add(a, b); + } else if (_175 === 1) { + v = two$u128_ref_u128_u128_ops_Add_add_u128_ref_u128((a016: rt.u128, a114: rt.u128): rt.u128 => { + return rt.u128Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.u128, a113: rt.u128): rt.u128 => { + return rt.u128Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _181: rt.u8 = rt.u8Rem(form, 3); + if (_181 === 0) { + v = rt.u128Sub(a, b); + } else if (_181 === 1) { + v = two$ref_u128_u128_u128_ops_Sub_sub_ref_u128_u128((a014: rt.u128, a112: rt.u128): rt.u128 => { + return rt.u128Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.u128, a111: rt.u128): rt.u128 => { + return rt.u128Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _187: rt.u8 = rt.u8Rem(form, 3); + if (_187 === 0) { + v = rt.u128Mul(a, b); + } else if (_187 === 1) { + v = two$ref_u128_ref_u128_u128_ops_Mul_mul_ref_u128_ref_u128((a012: rt.u128, a110: rt.u128): rt.u128 => { + return rt.u128Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.u128, a19: rt.u128): rt.u128 => { + return rt.u128Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _196: rt.u8 = rt.u8Rem(form, 3); + if (_196 === 0) { + v = rt.u128Shl(a, n & 0xff); + } else if (_196 === 1) { + v = two$ref_u128_ref_u8_u128_ops_Shl_shl_ref_u128_ref_u8((a010: rt.u128, a18: rt.u8): rt.u128 => { + return rt.u128Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.u128, a17: rt.u8): rt.u128 => { + return rt.u128Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _208: rt.u8 = rt.u8Rem(form, 3); + if (_208 === 0) { + v = rt.u128Not(a); + } else if (_208 === 1) { + v = one$ref_u128_u128_ops_Not_not_ref_u128((a08: rt.u128): rt.u128 => { + return rt.u128Not(a08); + }, a); + } else { + v = ((a07: rt.u128): rt.u128 => { + return rt.u128Not(a07); + })(a); + } + } else if (_30 === 29) { + let x11: rt.u128 = a; + const _216: rt.u8 = rt.u8Rem(form, 3); + if (_216 === 0) { + x11 = rt.u128Add(x11, b); + } else if (_216 === 1) { + two$mut_u128_ref_u128_unit_ops_AddAssign_add_assign_u128_ref_u128((a06: rt.Place, a16: rt.u128): undefined => { + a06.v = rt.u128Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.u128): undefined => { + a05.v = rt.u128Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.u128 = a; + const _227: rt.u8 = rt.u8Rem(form, 3); + if (_227 === 0) { + x12 = rt.u128Div(x12, b); + } else if (_227 === 1) { + two$mut_u128_ref_u128_unit_ops_DivAssign_div_assign_u128_ref_u128((a04: rt.Place, a14: rt.u128): undefined => { + a04.v = rt.u128Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.u128): undefined => { + a03.v = rt.u128Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.u128 = a; + const _238: rt.u8 = rt.u8Rem(form, 3); + if (_238 === 0) { + x13 = rt.u128Shr(x13, n & 0xffff); + } else if (_238 === 1) { + two$mut_u128_ref_u16_unit_ops_ShrAssign_shr_assign_u128_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.u128Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.u128Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.usize; + const _28: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v3: rt.usize): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); + }; + const take: (a0: rt.usize) => rt.usize = (at: rt.usize): rt.usize => { + const buf: Uint8Array = rt.bytes(4); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.usizeFromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.usize, rt.usize] = [take(1), take(1 + 4)]; + const a: rt.usize = _10[0]; + const b: rt.usize = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 4), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.usizeAdd(a, b); + } else if (_32 === 1) { + v = two$usize_usize_usize_ops_Add_add_usize_usize((a062: rt.usize, a158: rt.usize): rt.usize => { + return rt.usizeAdd(a062, a158); + }, a, b); + } else { + v = ((a061: rt.usize, a157: rt.usize): rt.usize => { + return rt.usizeAdd(a061, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.usizeSub(a, b); + } else if (_35 === 1) { + v = two$usize_usize_usize_ops_Sub_sub_usize_usize((a060: rt.usize, a156: rt.usize): rt.usize => { + return rt.usizeSub(a060, a156); + }, a, b); + } else { + v = ((a059: rt.usize, a155: rt.usize): rt.usize => { + return rt.usizeSub(a059, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.usizeMul(a, b); + } else if (_38 === 1) { + v = two$usize_usize_usize_ops_Mul_mul_usize_usize((a058: rt.usize, a154: rt.usize): rt.usize => { + return rt.usizeMul(a058, a154); + }, a, b); + } else { + v = ((a057: rt.usize, a153: rt.usize): rt.usize => { + return rt.usizeMul(a057, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.usizeDiv(a, b); + } else if (_41 === 1) { + v = two$usize_usize_usize_ops_Div_div_usize_usize((a056: rt.usize, a152: rt.usize): rt.usize => { + return rt.usizeDiv(a056, a152); + }, a, b); + } else { + v = ((a055: rt.usize, a151: rt.usize): rt.usize => { + return rt.usizeDiv(a055, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.usizeRem(a, b); + } else if (_44 === 1) { + v = two$usize_usize_usize_ops_Rem_rem_usize_usize((a054: rt.usize, a150: rt.usize): rt.usize => { + return rt.usizeRem(a054, a150); + }, a, b); + } else { + v = ((a053: rt.usize, a149: rt.usize): rt.usize => { + return rt.usizeRem(a053, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = (a & b) >>> 0; + } else if (_47 === 1) { + v = two$usize_usize_usize_ops_BitAnd_bitand_usize_usize((a052: rt.usize, a148: rt.usize): rt.usize => { + return (a052 & a148) >>> 0; + }, a, b); + } else { + v = ((a051: rt.usize, a147: rt.usize): rt.usize => { + return (a051 & a147) >>> 0; + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = (a | b) >>> 0; + } else if (_50 === 1) { + v = two$usize_usize_usize_ops_BitOr_bitor_usize_usize((a050: rt.usize, a146: rt.usize): rt.usize => { + return (a050 | a146) >>> 0; + }, a, b); + } else { + v = ((a049: rt.usize, a145: rt.usize): rt.usize => { + return (a049 | a145) >>> 0; + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = (a ^ b) >>> 0; + } else if (_53 === 1) { + v = two$usize_usize_usize_ops_BitXor_bitxor_usize_usize((a048: rt.usize, a144: rt.usize): rt.usize => { + return (a048 ^ a144) >>> 0; + }, a, b); + } else { + v = ((a047: rt.usize, a143: rt.usize): rt.usize => { + return (a047 ^ a143) >>> 0; + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.usizeShl(a, n); + } else if (_56 === 1) { + v = two$usize_u32_usize_ops_Shl_shl_usize_u32((a046: rt.usize, a142: rt.u32): rt.usize => { + return rt.usizeShl(a046, a142); + }, a, n); + } else { + v = ((a045: rt.usize, a141: rt.u32): rt.usize => { + return rt.usizeShl(a045, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.usizeShr(a, n); + } else if (_59 === 1) { + v = two$usize_u32_usize_ops_Shr_shr_usize_u32((a044: rt.usize, a140: rt.u32): rt.usize => { + return rt.usizeShr(a044, a140); + }, a, n); + } else { + v = ((a043: rt.usize, a139: rt.u32): rt.usize => { + return rt.usizeShr(a043, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.usizeShl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$usize_i16_usize_ops_Shl_shl_usize_i16((a042: rt.usize, a138: rt.i16): rt.usize => { + return rt.usizeShl(a042, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a041: rt.usize, a137: rt.i16): rt.usize => { + return rt.usizeShl(a041, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.usizeShr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$usize_u128_usize_ops_Shr_shr_usize_u128((a040: rt.usize, a136: rt.u128): rt.usize => { + return rt.usizeShr(a040, a136); + }, a, _74); + } else { + v = ((a039: rt.usize, a135: rt.u128): rt.usize => { + return rt.usizeShr(a039, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = ~a >>> 0; + } else if (_83 === 1) { + v = one$usize_usize_ops_Not_not_usize((a038: rt.usize): rt.usize => { + return ~a038 >>> 0; + }, a); + } else { + v = ((a037: rt.usize): rt.usize => { + return ~a037 >>> 0; + })(a); + } + } else if (_30 === 13) { + const _86 = undefined as rt.usize | undefined; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.usize = a; + const _91: rt.u8 = rt.u8Rem(form, 3); + if (_91 === 0) { + x = rt.usizeAdd(x, b); + } else if (_91 === 1) { + two$mut_usize_usize_unit_ops_AddAssign_add_assign_usize_usize((a036: rt.Place, a134: rt.usize): undefined => { + a036.v = rt.usizeAdd(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.usize): undefined => { + a035.v = rt.usizeAdd(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.usize = a; + const _99: rt.u8 = rt.u8Rem(form, 3); + if (_99 === 0) { + x2 = rt.usizeSub(x2, b); + } else if (_99 === 1) { + two$mut_usize_usize_unit_ops_SubAssign_sub_assign_usize_usize((a034: rt.Place, a132: rt.usize): undefined => { + a034.v = rt.usizeSub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.usize): undefined => { + a033.v = rt.usizeSub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.usize = a; + const _107: rt.u8 = rt.u8Rem(form, 3); + if (_107 === 0) { + x3 = rt.usizeMul(x3, b); + } else if (_107 === 1) { + two$mut_usize_usize_unit_ops_MulAssign_mul_assign_usize_usize((a032: rt.Place, a130: rt.usize): undefined => { + a032.v = rt.usizeMul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.usize): undefined => { + a031.v = rt.usizeMul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.usize = a; + const _115: rt.u8 = rt.u8Rem(form, 3); + if (_115 === 0) { + x4 = rt.usizeDiv(x4, b); + } else if (_115 === 1) { + two$mut_usize_usize_unit_ops_DivAssign_div_assign_usize_usize((a030: rt.Place, a128: rt.usize): undefined => { + a030.v = rt.usizeDiv(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.usize): undefined => { + a029.v = rt.usizeDiv(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.usize = a; + const _123: rt.u8 = rt.u8Rem(form, 3); + if (_123 === 0) { + x5 = rt.usizeRem(x5, b); + } else if (_123 === 1) { + two$mut_usize_usize_unit_ops_RemAssign_rem_assign_usize_usize((a028: rt.Place, a126: rt.usize): undefined => { + a028.v = rt.usizeRem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.usize): undefined => { + a027.v = rt.usizeRem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.usize = a; + const _131: rt.u8 = rt.u8Rem(form, 3); + if (_131 === 0) { + x6 = (x6 & b) >>> 0; + } else if (_131 === 1) { + two$mut_usize_usize_unit_ops_BitAndAssign_bitand_assign_usize_usize((a026: rt.Place, a124: rt.usize): undefined => { + a026.v = (a026.v & a124) >>> 0; + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.usize): undefined => { + a025.v = (a025.v & a123) >>> 0; + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.usize = a; + const _139: rt.u8 = rt.u8Rem(form, 3); + if (_139 === 0) { + x7 = (x7 | b) >>> 0; + } else if (_139 === 1) { + two$mut_usize_usize_unit_ops_BitOrAssign_bitor_assign_usize_usize((a024: rt.Place, a122: rt.usize): undefined => { + a024.v = (a024.v | a122) >>> 0; + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.usize): undefined => { + a023.v = (a023.v | a121) >>> 0; + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.usize = a; + const _147: rt.u8 = rt.u8Rem(form, 3); + if (_147 === 0) { + x8 = (x8 ^ b) >>> 0; + } else if (_147 === 1) { + two$mut_usize_usize_unit_ops_BitXorAssign_bitxor_assign_usize_usize((a022: rt.Place, a120: rt.usize): undefined => { + a022.v = (a022.v ^ a120) >>> 0; + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.usize): undefined => { + a021.v = (a021.v ^ a119) >>> 0; + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.usize = a; + const _155: rt.u8 = rt.u8Rem(form, 3); + if (_155 === 0) { + x9 = rt.usizeShl(x9, n); + } else if (_155 === 1) { + two$mut_usize_u32_unit_ops_ShlAssign_shl_assign_usize_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.usizeShl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.usizeShl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.usize = a; + const _163: rt.u8 = rt.u8Rem(form, 3); + if (_163 === 0) { + x10 = rt.usizeShr(x10, (n << 16) >> 16 as rt.i64); + } else if (_163 === 1) { + two$mut_usize_i64_unit_ops_ShrAssign_shr_assign_usize_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.usizeShr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.usizeShr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _175: rt.u8 = rt.u8Rem(form, 3); + if (_175 === 0) { + v = rt.usizeAdd(a, b); + } else if (_175 === 1) { + v = two$usize_ref_usize_usize_ops_Add_add_usize_ref_usize((a016: rt.usize, a114: rt.usize): rt.usize => { + return rt.usizeAdd(a016, a114); + }, a, b); + } else { + v = ((a015: rt.usize, a113: rt.usize): rt.usize => { + return rt.usizeAdd(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _181: rt.u8 = rt.u8Rem(form, 3); + if (_181 === 0) { + v = rt.usizeSub(a, b); + } else if (_181 === 1) { + v = two$ref_usize_usize_usize_ops_Sub_sub_ref_usize_usize((a014: rt.usize, a112: rt.usize): rt.usize => { + return rt.usizeSub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.usize, a111: rt.usize): rt.usize => { + return rt.usizeSub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _187: rt.u8 = rt.u8Rem(form, 3); + if (_187 === 0) { + v = rt.usizeMul(a, b); + } else if (_187 === 1) { + v = two$ref_usize_ref_usize_usize_ops_Mul_mul_ref_usize_ref_usize((a012: rt.usize, a110: rt.usize): rt.usize => { + return rt.usizeMul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.usize, a19: rt.usize): rt.usize => { + return rt.usizeMul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _196: rt.u8 = rt.u8Rem(form, 3); + if (_196 === 0) { + v = rt.usizeShl(a, n & 0xff); + } else if (_196 === 1) { + v = two$ref_usize_ref_u8_usize_ops_Shl_shl_ref_usize_ref_u8((a010: rt.usize, a18: rt.u8): rt.usize => { + return rt.usizeShl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.usize, a17: rt.u8): rt.usize => { + return rt.usizeShl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _208: rt.u8 = rt.u8Rem(form, 3); + if (_208 === 0) { + v = ~a >>> 0; + } else if (_208 === 1) { + v = one$ref_usize_usize_ops_Not_not_ref_usize((a08: rt.usize): rt.usize => { + return ~a08 >>> 0; + }, a); + } else { + v = ((a07: rt.usize): rt.usize => { + return ~a07 >>> 0; + })(a); + } + } else if (_30 === 29) { + let x11: rt.usize = a; + const _216: rt.u8 = rt.u8Rem(form, 3); + if (_216 === 0) { + x11 = rt.usizeAdd(x11, b); + } else if (_216 === 1) { + two$mut_usize_ref_usize_unit_ops_AddAssign_add_assign_usize_ref_usize((a06: rt.Place, a16: rt.usize): undefined => { + a06.v = rt.usizeAdd(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.usize): undefined => { + a05.v = rt.usizeAdd(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.usize = a; + const _227: rt.u8 = rt.u8Rem(form, 3); + if (_227 === 0) { + x12 = rt.usizeDiv(x12, b); + } else if (_227 === 1) { + two$mut_usize_ref_usize_unit_ops_DivAssign_div_assign_usize_ref_usize((a04: rt.Place, a14: rt.usize): undefined => { + a04.v = rt.usizeDiv(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.usize): undefined => { + a03.v = rt.usizeDiv(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.usize = a; + const _238: rt.u8 = rt.u8Rem(form, 3); + if (_238 === 0) { + x13 = rt.usizeShr(x13, n & 0xffff); + } else if (_238 === 1) { + two$mut_usize_ref_u16_unit_ops_ShrAssign_shr_assign_usize_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.usizeShr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.usizeShr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.i8; + let _87!: rt.i8; + const _28: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v3: rt.i8): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); + }; + const take: (a0: rt.usize) => rt.i8 = (at: rt.usize): rt.i8 => { + const buf: Uint8Array = Uint8Array.of(0); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.i8FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.i8, rt.i8] = [take(1), take(1 + 1)]; + const a: rt.i8 = _10[0]; + const b: rt.i8 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 1), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.i8Add(a, b); + } else if (_32 === 1) { + v = two$i8_i8_i8_ops_Add_add_i8_i8((a066: rt.i8, a158: rt.i8): rt.i8 => { + return rt.i8Add(a066, a158); + }, a, b); + } else { + v = ((a065: rt.i8, a157: rt.i8): rt.i8 => { + return rt.i8Add(a065, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.i8Sub(a, b); + } else if (_35 === 1) { + v = two$i8_i8_i8_ops_Sub_sub_i8_i8((a064: rt.i8, a156: rt.i8): rt.i8 => { + return rt.i8Sub(a064, a156); + }, a, b); + } else { + v = ((a063: rt.i8, a155: rt.i8): rt.i8 => { + return rt.i8Sub(a063, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.i8Mul(a, b); + } else if (_38 === 1) { + v = two$i8_i8_i8_ops_Mul_mul_i8_i8((a062: rt.i8, a154: rt.i8): rt.i8 => { + return rt.i8Mul(a062, a154); + }, a, b); + } else { + v = ((a061: rt.i8, a153: rt.i8): rt.i8 => { + return rt.i8Mul(a061, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.i8Div(a, b); + } else if (_41 === 1) { + v = two$i8_i8_i8_ops_Div_div_i8_i8((a060: rt.i8, a152: rt.i8): rt.i8 => { + return rt.i8Div(a060, a152); + }, a, b); + } else { + v = ((a059: rt.i8, a151: rt.i8): rt.i8 => { + return rt.i8Div(a059, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.i8Rem(a, b); + } else if (_44 === 1) { + v = two$i8_i8_i8_ops_Rem_rem_i8_i8((a058: rt.i8, a150: rt.i8): rt.i8 => { + return rt.i8Rem(a058, a150); + }, a, b); + } else { + v = ((a057: rt.i8, a149: rt.i8): rt.i8 => { + return rt.i8Rem(a057, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = a & b; + } else if (_47 === 1) { + v = two$i8_i8_i8_ops_BitAnd_bitand_i8_i8((a056: rt.i8, a148: rt.i8): rt.i8 => { + return a056 & a148; + }, a, b); + } else { + v = ((a055: rt.i8, a147: rt.i8): rt.i8 => { + return a055 & a147; + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = a | b; + } else if (_50 === 1) { + v = two$i8_i8_i8_ops_BitOr_bitor_i8_i8((a054: rt.i8, a146: rt.i8): rt.i8 => { + return a054 | a146; + }, a, b); + } else { + v = ((a053: rt.i8, a145: rt.i8): rt.i8 => { + return a053 | a145; + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = a ^ b; + } else if (_53 === 1) { + v = two$i8_i8_i8_ops_BitXor_bitxor_i8_i8((a052: rt.i8, a144: rt.i8): rt.i8 => { + return a052 ^ a144; + }, a, b); + } else { + v = ((a051: rt.i8, a143: rt.i8): rt.i8 => { + return a051 ^ a143; + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.i8Shl(a, n); + } else if (_56 === 1) { + v = two$i8_u32_i8_ops_Shl_shl_i8_u32((a050: rt.i8, a142: rt.u32): rt.i8 => { + return rt.i8Shl(a050, a142); + }, a, n); + } else { + v = ((a049: rt.i8, a141: rt.u32): rt.i8 => { + return rt.i8Shl(a049, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.i8Shr(a, n); + } else if (_59 === 1) { + v = two$i8_u32_i8_ops_Shr_shr_i8_u32((a048: rt.i8, a140: rt.u32): rt.i8 => { + return rt.i8Shr(a048, a140); + }, a, n); + } else { + v = ((a047: rt.i8, a139: rt.u32): rt.i8 => { + return rt.i8Shr(a047, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.i8Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$i8_i16_i8_ops_Shl_shl_i8_i16((a046: rt.i8, a138: rt.i16): rt.i8 => { + return rt.i8Shl(a046, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a045: rt.i8, a137: rt.i16): rt.i8 => { + return rt.i8Shl(a045, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.i8Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$i8_u128_i8_ops_Shr_shr_i8_u128((a044: rt.i8, a136: rt.u128): rt.i8 => { + return rt.i8Shr(a044, a136); + }, a, _74); + } else { + v = ((a043: rt.i8, a135: rt.u128): rt.i8 => { + return rt.i8Shr(a043, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = ~a; + } else if (_83 === 1) { + v = one$i8_i8_ops_Not_not_i8((a042: rt.i8): rt.i8 => { + return ~a042; + }, a); + } else { + v = ((a041: rt.i8): rt.i8 => { + return ~a041; + })(a); + } + } else if (_30 === 13) { + if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { + const _92: rt.u8 = rt.u8Rem(form, 3); + if (_92 === 0) { + _87 = rt.i8Neg(a); + } else if (_92 === 1) { + _87 = one$i8_i8_ops_Neg_neg_i8((a040: rt.i8): rt.i8 => { + return rt.i8Neg(a040); + }, a); + } else { + _87 = ((a039: rt.i8): rt.i8 => { + return rt.i8Neg(a039); + })(a); + } + } else { + const _95: rt.u8 = rt.u8Rem(form, 3); + if (_95 === 0) { + _87 = rt.i8Neg(a); + } else if (_95 === 1) { + _87 = one$ref_i8_i8_ops_Neg_neg_ref_i8((a038: rt.i8): rt.i8 => { + return rt.i8Neg(a038); + }, a); + } else { + _87 = ((a037: rt.i8): rt.i8 => { + return rt.i8Neg(a037); + })(a); + } + } + const _86: rt.i8 | undefined = _87; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.i8 = a; + const _105: rt.u8 = rt.u8Rem(form, 3); + if (_105 === 0) { + x = rt.i8Add(x, b); + } else if (_105 === 1) { + two$mut_i8_i8_unit_ops_AddAssign_add_assign_i8_i8((a036: rt.Place, a134: rt.i8): undefined => { + a036.v = rt.i8Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.i8): undefined => { + a035.v = rt.i8Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.i8 = a; + const _113: rt.u8 = rt.u8Rem(form, 3); + if (_113 === 0) { + x2 = rt.i8Sub(x2, b); + } else if (_113 === 1) { + two$mut_i8_i8_unit_ops_SubAssign_sub_assign_i8_i8((a034: rt.Place, a132: rt.i8): undefined => { + a034.v = rt.i8Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.i8): undefined => { + a033.v = rt.i8Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.i8 = a; + const _121: rt.u8 = rt.u8Rem(form, 3); + if (_121 === 0) { + x3 = rt.i8Mul(x3, b); + } else if (_121 === 1) { + two$mut_i8_i8_unit_ops_MulAssign_mul_assign_i8_i8((a032: rt.Place, a130: rt.i8): undefined => { + a032.v = rt.i8Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.i8): undefined => { + a031.v = rt.i8Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.i8 = a; + const _129: rt.u8 = rt.u8Rem(form, 3); + if (_129 === 0) { + x4 = rt.i8Div(x4, b); + } else if (_129 === 1) { + two$mut_i8_i8_unit_ops_DivAssign_div_assign_i8_i8((a030: rt.Place, a128: rt.i8): undefined => { + a030.v = rt.i8Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.i8): undefined => { + a029.v = rt.i8Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.i8 = a; + const _137: rt.u8 = rt.u8Rem(form, 3); + if (_137 === 0) { + x5 = rt.i8Rem(x5, b); + } else if (_137 === 1) { + two$mut_i8_i8_unit_ops_RemAssign_rem_assign_i8_i8((a028: rt.Place, a126: rt.i8): undefined => { + a028.v = rt.i8Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.i8): undefined => { + a027.v = rt.i8Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.i8 = a; + const _145: rt.u8 = rt.u8Rem(form, 3); + if (_145 === 0) { + x6 = x6 & b; + } else if (_145 === 1) { + two$mut_i8_i8_unit_ops_BitAndAssign_bitand_assign_i8_i8((a026: rt.Place, a124: rt.i8): undefined => { + a026.v = a026.v & a124; + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.i8): undefined => { + a025.v = a025.v & a123; + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.i8 = a; + const _153: rt.u8 = rt.u8Rem(form, 3); + if (_153 === 0) { + x7 = x7 | b; + } else if (_153 === 1) { + two$mut_i8_i8_unit_ops_BitOrAssign_bitor_assign_i8_i8((a024: rt.Place, a122: rt.i8): undefined => { + a024.v = a024.v | a122; + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.i8): undefined => { + a023.v = a023.v | a121; + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.i8 = a; + const _161: rt.u8 = rt.u8Rem(form, 3); + if (_161 === 0) { + x8 = x8 ^ b; + } else if (_161 === 1) { + two$mut_i8_i8_unit_ops_BitXorAssign_bitxor_assign_i8_i8((a022: rt.Place, a120: rt.i8): undefined => { + a022.v = a022.v ^ a120; + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.i8): undefined => { + a021.v = a021.v ^ a119; + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.i8 = a; + const _169: rt.u8 = rt.u8Rem(form, 3); + if (_169 === 0) { + x9 = rt.i8Shl(x9, n); + } else if (_169 === 1) { + two$mut_i8_u32_unit_ops_ShlAssign_shl_assign_i8_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.i8Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.i8Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.i8 = a; + const _177: rt.u8 = rt.u8Rem(form, 3); + if (_177 === 0) { + x10 = rt.i8Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_177 === 1) { + two$mut_i8_i64_unit_ops_ShrAssign_shr_assign_i8_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.i8Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.i8Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _189: rt.u8 = rt.u8Rem(form, 3); + if (_189 === 0) { + v = rt.i8Add(a, b); + } else if (_189 === 1) { + v = two$i8_ref_i8_i8_ops_Add_add_i8_ref_i8((a016: rt.i8, a114: rt.i8): rt.i8 => { + return rt.i8Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.i8, a113: rt.i8): rt.i8 => { + return rt.i8Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _195: rt.u8 = rt.u8Rem(form, 3); + if (_195 === 0) { + v = rt.i8Sub(a, b); + } else if (_195 === 1) { + v = two$ref_i8_i8_i8_ops_Sub_sub_ref_i8_i8((a014: rt.i8, a112: rt.i8): rt.i8 => { + return rt.i8Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.i8, a111: rt.i8): rt.i8 => { + return rt.i8Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _201: rt.u8 = rt.u8Rem(form, 3); + if (_201 === 0) { + v = rt.i8Mul(a, b); + } else if (_201 === 1) { + v = two$ref_i8_ref_i8_i8_ops_Mul_mul_ref_i8_ref_i8((a012: rt.i8, a110: rt.i8): rt.i8 => { + return rt.i8Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.i8, a19: rt.i8): rt.i8 => { + return rt.i8Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _210: rt.u8 = rt.u8Rem(form, 3); + if (_210 === 0) { + v = rt.i8Shl(a, n & 0xff); + } else if (_210 === 1) { + v = two$ref_i8_ref_u8_i8_ops_Shl_shl_ref_i8_ref_u8((a010: rt.i8, a18: rt.u8): rt.i8 => { + return rt.i8Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.i8, a17: rt.u8): rt.i8 => { + return rt.i8Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _222: rt.u8 = rt.u8Rem(form, 3); + if (_222 === 0) { + v = ~a; + } else if (_222 === 1) { + v = one$ref_i8_i8_ops_Not_not_ref_i8((a08: rt.i8): rt.i8 => { + return ~a08; + }, a); + } else { + v = ((a07: rt.i8): rt.i8 => { + return ~a07; + })(a); + } + } else if (_30 === 29) { + let x11: rt.i8 = a; + const _230: rt.u8 = rt.u8Rem(form, 3); + if (_230 === 0) { + x11 = rt.i8Add(x11, b); + } else if (_230 === 1) { + two$mut_i8_ref_i8_unit_ops_AddAssign_add_assign_i8_ref_i8((a06: rt.Place, a16: rt.i8): undefined => { + a06.v = rt.i8Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.i8): undefined => { + a05.v = rt.i8Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.i8 = a; + const _241: rt.u8 = rt.u8Rem(form, 3); + if (_241 === 0) { + x12 = rt.i8Div(x12, b); + } else if (_241 === 1) { + two$mut_i8_ref_i8_unit_ops_DivAssign_div_assign_i8_ref_i8((a04: rt.Place, a14: rt.i8): undefined => { + a04.v = rt.i8Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.i8): undefined => { + a03.v = rt.i8Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.i8 = a; + const _252: rt.u8 = rt.u8Rem(form, 3); + if (_252 === 0) { + x13 = rt.i8Shr(x13, n & 0xffff); + } else if (_252 === 1) { + two$mut_i8_ref_u16_unit_ops_ShrAssign_shr_assign_i8_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.i8Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i8Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.i16; + let _87!: rt.i16; + const _28: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v3: rt.i16): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); + }; + const take: (a0: rt.usize) => rt.i16 = (at: rt.usize): rt.i16 => { + const buf: Uint8Array = rt.bytes(2); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.i16FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.i16, rt.i16] = [take(1), take(1 + 2)]; + const a: rt.i16 = _10[0]; + const b: rt.i16 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 2), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.i16Add(a, b); + } else if (_32 === 1) { + v = two$i16_i16_i16_ops_Add_add_i16_i16((a066: rt.i16, a158: rt.i16): rt.i16 => { + return rt.i16Add(a066, a158); + }, a, b); + } else { + v = ((a065: rt.i16, a157: rt.i16): rt.i16 => { + return rt.i16Add(a065, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.i16Sub(a, b); + } else if (_35 === 1) { + v = two$i16_i16_i16_ops_Sub_sub_i16_i16((a064: rt.i16, a156: rt.i16): rt.i16 => { + return rt.i16Sub(a064, a156); + }, a, b); + } else { + v = ((a063: rt.i16, a155: rt.i16): rt.i16 => { + return rt.i16Sub(a063, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.i16Mul(a, b); + } else if (_38 === 1) { + v = two$i16_i16_i16_ops_Mul_mul_i16_i16((a062: rt.i16, a154: rt.i16): rt.i16 => { + return rt.i16Mul(a062, a154); + }, a, b); + } else { + v = ((a061: rt.i16, a153: rt.i16): rt.i16 => { + return rt.i16Mul(a061, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.i16Div(a, b); + } else if (_41 === 1) { + v = two$i16_i16_i16_ops_Div_div_i16_i16((a060: rt.i16, a152: rt.i16): rt.i16 => { + return rt.i16Div(a060, a152); + }, a, b); + } else { + v = ((a059: rt.i16, a151: rt.i16): rt.i16 => { + return rt.i16Div(a059, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.i16Rem(a, b); + } else if (_44 === 1) { + v = two$i16_i16_i16_ops_Rem_rem_i16_i16((a058: rt.i16, a150: rt.i16): rt.i16 => { + return rt.i16Rem(a058, a150); + }, a, b); + } else { + v = ((a057: rt.i16, a149: rt.i16): rt.i16 => { + return rt.i16Rem(a057, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = a & b; + } else if (_47 === 1) { + v = two$i16_i16_i16_ops_BitAnd_bitand_i16_i16((a056: rt.i16, a148: rt.i16): rt.i16 => { + return a056 & a148; + }, a, b); + } else { + v = ((a055: rt.i16, a147: rt.i16): rt.i16 => { + return a055 & a147; + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = a | b; + } else if (_50 === 1) { + v = two$i16_i16_i16_ops_BitOr_bitor_i16_i16((a054: rt.i16, a146: rt.i16): rt.i16 => { + return a054 | a146; + }, a, b); + } else { + v = ((a053: rt.i16, a145: rt.i16): rt.i16 => { + return a053 | a145; + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = a ^ b; + } else if (_53 === 1) { + v = two$i16_i16_i16_ops_BitXor_bitxor_i16_i16((a052: rt.i16, a144: rt.i16): rt.i16 => { + return a052 ^ a144; + }, a, b); + } else { + v = ((a051: rt.i16, a143: rt.i16): rt.i16 => { + return a051 ^ a143; + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.i16Shl(a, n); + } else if (_56 === 1) { + v = two$i16_u32_i16_ops_Shl_shl_i16_u32((a050: rt.i16, a142: rt.u32): rt.i16 => { + return rt.i16Shl(a050, a142); + }, a, n); + } else { + v = ((a049: rt.i16, a141: rt.u32): rt.i16 => { + return rt.i16Shl(a049, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.i16Shr(a, n); + } else if (_59 === 1) { + v = two$i16_u32_i16_ops_Shr_shr_i16_u32((a048: rt.i16, a140: rt.u32): rt.i16 => { + return rt.i16Shr(a048, a140); + }, a, n); + } else { + v = ((a047: rt.i16, a139: rt.u32): rt.i16 => { + return rt.i16Shr(a047, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.i16Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$i16_i16_i16_ops_Shl_shl_i16_i16((a046: rt.i16, a138: rt.i16): rt.i16 => { + return rt.i16Shl(a046, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a045: rt.i16, a137: rt.i16): rt.i16 => { + return rt.i16Shl(a045, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.i16Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$i16_u128_i16_ops_Shr_shr_i16_u128((a044: rt.i16, a136: rt.u128): rt.i16 => { + return rt.i16Shr(a044, a136); + }, a, _74); + } else { + v = ((a043: rt.i16, a135: rt.u128): rt.i16 => { + return rt.i16Shr(a043, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = ~a; + } else if (_83 === 1) { + v = one$i16_i16_ops_Not_not_i16((a042: rt.i16): rt.i16 => { + return ~a042; + }, a); + } else { + v = ((a041: rt.i16): rt.i16 => { + return ~a041; + })(a); + } + } else if (_30 === 13) { + if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { + const _92: rt.u8 = rt.u8Rem(form, 3); + if (_92 === 0) { + _87 = rt.i16Neg(a); + } else if (_92 === 1) { + _87 = one$i16_i16_ops_Neg_neg_i16((a040: rt.i16): rt.i16 => { + return rt.i16Neg(a040); + }, a); + } else { + _87 = ((a039: rt.i16): rt.i16 => { + return rt.i16Neg(a039); + })(a); + } + } else { + const _95: rt.u8 = rt.u8Rem(form, 3); + if (_95 === 0) { + _87 = rt.i16Neg(a); + } else if (_95 === 1) { + _87 = one$ref_i16_i16_ops_Neg_neg_ref_i16((a038: rt.i16): rt.i16 => { + return rt.i16Neg(a038); + }, a); + } else { + _87 = ((a037: rt.i16): rt.i16 => { + return rt.i16Neg(a037); + })(a); + } + } + const _86: rt.i16 | undefined = _87; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.i16 = a; + const _105: rt.u8 = rt.u8Rem(form, 3); + if (_105 === 0) { + x = rt.i16Add(x, b); + } else if (_105 === 1) { + two$mut_i16_i16_unit_ops_AddAssign_add_assign_i16_i16((a036: rt.Place, a134: rt.i16): undefined => { + a036.v = rt.i16Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.i16): undefined => { + a035.v = rt.i16Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.i16 = a; + const _113: rt.u8 = rt.u8Rem(form, 3); + if (_113 === 0) { + x2 = rt.i16Sub(x2, b); + } else if (_113 === 1) { + two$mut_i16_i16_unit_ops_SubAssign_sub_assign_i16_i16((a034: rt.Place, a132: rt.i16): undefined => { + a034.v = rt.i16Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.i16): undefined => { + a033.v = rt.i16Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.i16 = a; + const _121: rt.u8 = rt.u8Rem(form, 3); + if (_121 === 0) { + x3 = rt.i16Mul(x3, b); + } else if (_121 === 1) { + two$mut_i16_i16_unit_ops_MulAssign_mul_assign_i16_i16((a032: rt.Place, a130: rt.i16): undefined => { + a032.v = rt.i16Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.i16): undefined => { + a031.v = rt.i16Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.i16 = a; + const _129: rt.u8 = rt.u8Rem(form, 3); + if (_129 === 0) { + x4 = rt.i16Div(x4, b); + } else if (_129 === 1) { + two$mut_i16_i16_unit_ops_DivAssign_div_assign_i16_i16((a030: rt.Place, a128: rt.i16): undefined => { + a030.v = rt.i16Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.i16): undefined => { + a029.v = rt.i16Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.i16 = a; + const _137: rt.u8 = rt.u8Rem(form, 3); + if (_137 === 0) { + x5 = rt.i16Rem(x5, b); + } else if (_137 === 1) { + two$mut_i16_i16_unit_ops_RemAssign_rem_assign_i16_i16((a028: rt.Place, a126: rt.i16): undefined => { + a028.v = rt.i16Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.i16): undefined => { + a027.v = rt.i16Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.i16 = a; + const _145: rt.u8 = rt.u8Rem(form, 3); + if (_145 === 0) { + x6 = x6 & b; + } else if (_145 === 1) { + two$mut_i16_i16_unit_ops_BitAndAssign_bitand_assign_i16_i16((a026: rt.Place, a124: rt.i16): undefined => { + a026.v = a026.v & a124; + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.i16): undefined => { + a025.v = a025.v & a123; + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.i16 = a; + const _153: rt.u8 = rt.u8Rem(form, 3); + if (_153 === 0) { + x7 = x7 | b; + } else if (_153 === 1) { + two$mut_i16_i16_unit_ops_BitOrAssign_bitor_assign_i16_i16((a024: rt.Place, a122: rt.i16): undefined => { + a024.v = a024.v | a122; + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.i16): undefined => { + a023.v = a023.v | a121; + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.i16 = a; + const _161: rt.u8 = rt.u8Rem(form, 3); + if (_161 === 0) { + x8 = x8 ^ b; + } else if (_161 === 1) { + two$mut_i16_i16_unit_ops_BitXorAssign_bitxor_assign_i16_i16((a022: rt.Place, a120: rt.i16): undefined => { + a022.v = a022.v ^ a120; + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.i16): undefined => { + a021.v = a021.v ^ a119; + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.i16 = a; + const _169: rt.u8 = rt.u8Rem(form, 3); + if (_169 === 0) { + x9 = rt.i16Shl(x9, n); + } else if (_169 === 1) { + two$mut_i16_u32_unit_ops_ShlAssign_shl_assign_i16_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.i16Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.i16Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.i16 = a; + const _177: rt.u8 = rt.u8Rem(form, 3); + if (_177 === 0) { + x10 = rt.i16Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_177 === 1) { + two$mut_i16_i64_unit_ops_ShrAssign_shr_assign_i16_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.i16Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.i16Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _189: rt.u8 = rt.u8Rem(form, 3); + if (_189 === 0) { + v = rt.i16Add(a, b); + } else if (_189 === 1) { + v = two$i16_ref_i16_i16_ops_Add_add_i16_ref_i16((a016: rt.i16, a114: rt.i16): rt.i16 => { + return rt.i16Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.i16, a113: rt.i16): rt.i16 => { + return rt.i16Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _195: rt.u8 = rt.u8Rem(form, 3); + if (_195 === 0) { + v = rt.i16Sub(a, b); + } else if (_195 === 1) { + v = two$ref_i16_i16_i16_ops_Sub_sub_ref_i16_i16((a014: rt.i16, a112: rt.i16): rt.i16 => { + return rt.i16Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.i16, a111: rt.i16): rt.i16 => { + return rt.i16Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _201: rt.u8 = rt.u8Rem(form, 3); + if (_201 === 0) { + v = rt.i16Mul(a, b); + } else if (_201 === 1) { + v = two$ref_i16_ref_i16_i16_ops_Mul_mul_ref_i16_ref_i16((a012: rt.i16, a110: rt.i16): rt.i16 => { + return rt.i16Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.i16, a19: rt.i16): rt.i16 => { + return rt.i16Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _210: rt.u8 = rt.u8Rem(form, 3); + if (_210 === 0) { + v = rt.i16Shl(a, n & 0xff); + } else if (_210 === 1) { + v = two$ref_i16_ref_u8_i16_ops_Shl_shl_ref_i16_ref_u8((a010: rt.i16, a18: rt.u8): rt.i16 => { + return rt.i16Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.i16, a17: rt.u8): rt.i16 => { + return rt.i16Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _222: rt.u8 = rt.u8Rem(form, 3); + if (_222 === 0) { + v = ~a; + } else if (_222 === 1) { + v = one$ref_i16_i16_ops_Not_not_ref_i16((a08: rt.i16): rt.i16 => { + return ~a08; + }, a); + } else { + v = ((a07: rt.i16): rt.i16 => { + return ~a07; + })(a); + } + } else if (_30 === 29) { + let x11: rt.i16 = a; + const _230: rt.u8 = rt.u8Rem(form, 3); + if (_230 === 0) { + x11 = rt.i16Add(x11, b); + } else if (_230 === 1) { + two$mut_i16_ref_i16_unit_ops_AddAssign_add_assign_i16_ref_i16((a06: rt.Place, a16: rt.i16): undefined => { + a06.v = rt.i16Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.i16): undefined => { + a05.v = rt.i16Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.i16 = a; + const _241: rt.u8 = rt.u8Rem(form, 3); + if (_241 === 0) { + x12 = rt.i16Div(x12, b); + } else if (_241 === 1) { + two$mut_i16_ref_i16_unit_ops_DivAssign_div_assign_i16_ref_i16((a04: rt.Place, a14: rt.i16): undefined => { + a04.v = rt.i16Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.i16): undefined => { + a03.v = rt.i16Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.i16 = a; + const _252: rt.u8 = rt.u8Rem(form, 3); + if (_252 === 0) { + x13 = rt.i16Shr(x13, n & 0xffff); + } else if (_252 === 1) { + two$mut_i16_ref_u16_unit_ops_ShrAssign_shr_assign_i16_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.i16Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i16Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.i32; + let _87!: rt.i32; + const _28: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v3: rt.i32): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); + }; + const take: (a0: rt.usize) => rt.i32 = (at: rt.usize): rt.i32 => { + const buf: Uint8Array = rt.bytes(4); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.i32FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.i32, rt.i32] = [take(1), take(1 + 4)]; + const a: rt.i32 = _10[0]; + const b: rt.i32 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 4), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.i32Add(a, b); + } else if (_32 === 1) { + v = two$i32_i32_i32_ops_Add_add_i32_i32((a066: rt.i32, a158: rt.i32): rt.i32 => { + return rt.i32Add(a066, a158); + }, a, b); + } else { + v = ((a065: rt.i32, a157: rt.i32): rt.i32 => { + return rt.i32Add(a065, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.i32Sub(a, b); + } else if (_35 === 1) { + v = two$i32_i32_i32_ops_Sub_sub_i32_i32((a064: rt.i32, a156: rt.i32): rt.i32 => { + return rt.i32Sub(a064, a156); + }, a, b); + } else { + v = ((a063: rt.i32, a155: rt.i32): rt.i32 => { + return rt.i32Sub(a063, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.i32Mul(a, b); + } else if (_38 === 1) { + v = two$i32_i32_i32_ops_Mul_mul_i32_i32((a062: rt.i32, a154: rt.i32): rt.i32 => { + return rt.i32Mul(a062, a154); + }, a, b); + } else { + v = ((a061: rt.i32, a153: rt.i32): rt.i32 => { + return rt.i32Mul(a061, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.i32Div(a, b); + } else if (_41 === 1) { + v = two$i32_i32_i32_ops_Div_div_i32_i32((a060: rt.i32, a152: rt.i32): rt.i32 => { + return rt.i32Div(a060, a152); + }, a, b); + } else { + v = ((a059: rt.i32, a151: rt.i32): rt.i32 => { + return rt.i32Div(a059, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.i32Rem(a, b); + } else if (_44 === 1) { + v = two$i32_i32_i32_ops_Rem_rem_i32_i32((a058: rt.i32, a150: rt.i32): rt.i32 => { + return rt.i32Rem(a058, a150); + }, a, b); + } else { + v = ((a057: rt.i32, a149: rt.i32): rt.i32 => { + return rt.i32Rem(a057, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = a & b; + } else if (_47 === 1) { + v = two$i32_i32_i32_ops_BitAnd_bitand_i32_i32((a056: rt.i32, a148: rt.i32): rt.i32 => { + return a056 & a148; + }, a, b); + } else { + v = ((a055: rt.i32, a147: rt.i32): rt.i32 => { + return a055 & a147; + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = a | b; + } else if (_50 === 1) { + v = two$i32_i32_i32_ops_BitOr_bitor_i32_i32((a054: rt.i32, a146: rt.i32): rt.i32 => { + return a054 | a146; + }, a, b); + } else { + v = ((a053: rt.i32, a145: rt.i32): rt.i32 => { + return a053 | a145; + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = a ^ b; + } else if (_53 === 1) { + v = two$i32_i32_i32_ops_BitXor_bitxor_i32_i32((a052: rt.i32, a144: rt.i32): rt.i32 => { + return a052 ^ a144; + }, a, b); + } else { + v = ((a051: rt.i32, a143: rt.i32): rt.i32 => { + return a051 ^ a143; + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.i32Shl(a, n); + } else if (_56 === 1) { + v = two$i32_u32_i32_ops_Shl_shl_i32_u32((a050: rt.i32, a142: rt.u32): rt.i32 => { + return rt.i32Shl(a050, a142); + }, a, n); + } else { + v = ((a049: rt.i32, a141: rt.u32): rt.i32 => { + return rt.i32Shl(a049, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.i32Shr(a, n); + } else if (_59 === 1) { + v = two$i32_u32_i32_ops_Shr_shr_i32_u32((a048: rt.i32, a140: rt.u32): rt.i32 => { + return rt.i32Shr(a048, a140); + }, a, n); + } else { + v = ((a047: rt.i32, a139: rt.u32): rt.i32 => { + return rt.i32Shr(a047, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.i32Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$i32_i16_i32_ops_Shl_shl_i32_i16((a046: rt.i32, a138: rt.i16): rt.i32 => { + return rt.i32Shl(a046, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a045: rt.i32, a137: rt.i16): rt.i32 => { + return rt.i32Shl(a045, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.i32Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$i32_u128_i32_ops_Shr_shr_i32_u128((a044: rt.i32, a136: rt.u128): rt.i32 => { + return rt.i32Shr(a044, a136); + }, a, _74); + } else { + v = ((a043: rt.i32, a135: rt.u128): rt.i32 => { + return rt.i32Shr(a043, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = ~a; + } else if (_83 === 1) { + v = one$i32_i32_ops_Not_not_i32((a042: rt.i32): rt.i32 => { + return ~a042; + }, a); + } else { + v = ((a041: rt.i32): rt.i32 => { + return ~a041; + })(a); + } + } else if (_30 === 13) { + if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { + const _92: rt.u8 = rt.u8Rem(form, 3); + if (_92 === 0) { + _87 = rt.i32Neg(a); + } else if (_92 === 1) { + _87 = one$i32_i32_ops_Neg_neg_i32((a040: rt.i32): rt.i32 => { + return rt.i32Neg(a040); + }, a); + } else { + _87 = ((a039: rt.i32): rt.i32 => { + return rt.i32Neg(a039); + })(a); + } + } else { + const _95: rt.u8 = rt.u8Rem(form, 3); + if (_95 === 0) { + _87 = rt.i32Neg(a); + } else if (_95 === 1) { + _87 = one$ref_i32_i32_ops_Neg_neg_ref_i32((a038: rt.i32): rt.i32 => { + return rt.i32Neg(a038); + }, a); + } else { + _87 = ((a037: rt.i32): rt.i32 => { + return rt.i32Neg(a037); + })(a); + } + } + const _86: rt.i32 | undefined = _87; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.i32 = a; + const _105: rt.u8 = rt.u8Rem(form, 3); + if (_105 === 0) { + x = rt.i32Add(x, b); + } else if (_105 === 1) { + two$mut_i32_i32_unit_ops_AddAssign_add_assign_i32_i32((a036: rt.Place, a134: rt.i32): undefined => { + a036.v = rt.i32Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.i32): undefined => { + a035.v = rt.i32Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.i32 = a; + const _113: rt.u8 = rt.u8Rem(form, 3); + if (_113 === 0) { + x2 = rt.i32Sub(x2, b); + } else if (_113 === 1) { + two$mut_i32_i32_unit_ops_SubAssign_sub_assign_i32_i32((a034: rt.Place, a132: rt.i32): undefined => { + a034.v = rt.i32Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.i32): undefined => { + a033.v = rt.i32Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.i32 = a; + const _121: rt.u8 = rt.u8Rem(form, 3); + if (_121 === 0) { + x3 = rt.i32Mul(x3, b); + } else if (_121 === 1) { + two$mut_i32_i32_unit_ops_MulAssign_mul_assign_i32_i32((a032: rt.Place, a130: rt.i32): undefined => { + a032.v = rt.i32Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.i32): undefined => { + a031.v = rt.i32Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.i32 = a; + const _129: rt.u8 = rt.u8Rem(form, 3); + if (_129 === 0) { + x4 = rt.i32Div(x4, b); + } else if (_129 === 1) { + two$mut_i32_i32_unit_ops_DivAssign_div_assign_i32_i32((a030: rt.Place, a128: rt.i32): undefined => { + a030.v = rt.i32Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.i32): undefined => { + a029.v = rt.i32Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.i32 = a; + const _137: rt.u8 = rt.u8Rem(form, 3); + if (_137 === 0) { + x5 = rt.i32Rem(x5, b); + } else if (_137 === 1) { + two$mut_i32_i32_unit_ops_RemAssign_rem_assign_i32_i32((a028: rt.Place, a126: rt.i32): undefined => { + a028.v = rt.i32Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.i32): undefined => { + a027.v = rt.i32Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.i32 = a; + const _145: rt.u8 = rt.u8Rem(form, 3); + if (_145 === 0) { + x6 = x6 & b; + } else if (_145 === 1) { + two$mut_i32_i32_unit_ops_BitAndAssign_bitand_assign_i32_i32((a026: rt.Place, a124: rt.i32): undefined => { + a026.v = a026.v & a124; + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.i32): undefined => { + a025.v = a025.v & a123; + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.i32 = a; + const _153: rt.u8 = rt.u8Rem(form, 3); + if (_153 === 0) { + x7 = x7 | b; + } else if (_153 === 1) { + two$mut_i32_i32_unit_ops_BitOrAssign_bitor_assign_i32_i32((a024: rt.Place, a122: rt.i32): undefined => { + a024.v = a024.v | a122; + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.i32): undefined => { + a023.v = a023.v | a121; + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.i32 = a; + const _161: rt.u8 = rt.u8Rem(form, 3); + if (_161 === 0) { + x8 = x8 ^ b; + } else if (_161 === 1) { + two$mut_i32_i32_unit_ops_BitXorAssign_bitxor_assign_i32_i32((a022: rt.Place, a120: rt.i32): undefined => { + a022.v = a022.v ^ a120; + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.i32): undefined => { + a021.v = a021.v ^ a119; + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.i32 = a; + const _169: rt.u8 = rt.u8Rem(form, 3); + if (_169 === 0) { + x9 = rt.i32Shl(x9, n); + } else if (_169 === 1) { + two$mut_i32_u32_unit_ops_ShlAssign_shl_assign_i32_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.i32Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.i32Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.i32 = a; + const _177: rt.u8 = rt.u8Rem(form, 3); + if (_177 === 0) { + x10 = rt.i32Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_177 === 1) { + two$mut_i32_i64_unit_ops_ShrAssign_shr_assign_i32_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.i32Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.i32Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _189: rt.u8 = rt.u8Rem(form, 3); + if (_189 === 0) { + v = rt.i32Add(a, b); + } else if (_189 === 1) { + v = two$i32_ref_i32_i32_ops_Add_add_i32_ref_i32((a016: rt.i32, a114: rt.i32): rt.i32 => { + return rt.i32Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.i32, a113: rt.i32): rt.i32 => { + return rt.i32Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _195: rt.u8 = rt.u8Rem(form, 3); + if (_195 === 0) { + v = rt.i32Sub(a, b); + } else if (_195 === 1) { + v = two$ref_i32_i32_i32_ops_Sub_sub_ref_i32_i32((a014: rt.i32, a112: rt.i32): rt.i32 => { + return rt.i32Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.i32, a111: rt.i32): rt.i32 => { + return rt.i32Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _201: rt.u8 = rt.u8Rem(form, 3); + if (_201 === 0) { + v = rt.i32Mul(a, b); + } else if (_201 === 1) { + v = two$ref_i32_ref_i32_i32_ops_Mul_mul_ref_i32_ref_i32((a012: rt.i32, a110: rt.i32): rt.i32 => { + return rt.i32Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.i32, a19: rt.i32): rt.i32 => { + return rt.i32Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _210: rt.u8 = rt.u8Rem(form, 3); + if (_210 === 0) { + v = rt.i32Shl(a, n & 0xff); + } else if (_210 === 1) { + v = two$ref_i32_ref_u8_i32_ops_Shl_shl_ref_i32_ref_u8((a010: rt.i32, a18: rt.u8): rt.i32 => { + return rt.i32Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.i32, a17: rt.u8): rt.i32 => { + return rt.i32Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _222: rt.u8 = rt.u8Rem(form, 3); + if (_222 === 0) { + v = ~a; + } else if (_222 === 1) { + v = one$ref_i32_i32_ops_Not_not_ref_i32((a08: rt.i32): rt.i32 => { + return ~a08; + }, a); + } else { + v = ((a07: rt.i32): rt.i32 => { + return ~a07; + })(a); + } + } else if (_30 === 29) { + let x11: rt.i32 = a; + const _230: rt.u8 = rt.u8Rem(form, 3); + if (_230 === 0) { + x11 = rt.i32Add(x11, b); + } else if (_230 === 1) { + two$mut_i32_ref_i32_unit_ops_AddAssign_add_assign_i32_ref_i32((a06: rt.Place, a16: rt.i32): undefined => { + a06.v = rt.i32Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.i32): undefined => { + a05.v = rt.i32Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.i32 = a; + const _241: rt.u8 = rt.u8Rem(form, 3); + if (_241 === 0) { + x12 = rt.i32Div(x12, b); + } else if (_241 === 1) { + two$mut_i32_ref_i32_unit_ops_DivAssign_div_assign_i32_ref_i32((a04: rt.Place, a14: rt.i32): undefined => { + a04.v = rt.i32Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.i32): undefined => { + a03.v = rt.i32Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.i32 = a; + const _252: rt.u8 = rt.u8Rem(form, 3); + if (_252 === 0) { + x13 = rt.i32Shr(x13, n & 0xffff); + } else if (_252 === 1) { + two$mut_i32_ref_u16_unit_ops_ShrAssign_shr_assign_i32_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.i32Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i32Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.i64; + let _87!: rt.i64; + const _28: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v3: rt.i64): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(v3)))); + }; + const take: (a0: rt.usize) => rt.i64 = (at: rt.usize): rt.i64 => { + const buf: Uint8Array = rt.bytes(8); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.i64FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.i64, rt.i64] = [take(1), take(1 + 8)]; + const a: rt.i64 = _10[0]; + const b: rt.i64 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 8), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.i64Add(a, b); + } else if (_32 === 1) { + v = two$i64_i64_i64_ops_Add_add_i64_i64((a066: rt.i64, a158: rt.i64): rt.i64 => { + return rt.i64Add(a066, a158); + }, a, b); + } else { + v = ((a065: rt.i64, a157: rt.i64): rt.i64 => { + return rt.i64Add(a065, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.i64Sub(a, b); + } else if (_35 === 1) { + v = two$i64_i64_i64_ops_Sub_sub_i64_i64((a064: rt.i64, a156: rt.i64): rt.i64 => { + return rt.i64Sub(a064, a156); + }, a, b); + } else { + v = ((a063: rt.i64, a155: rt.i64): rt.i64 => { + return rt.i64Sub(a063, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.i64Mul(a, b); + } else if (_38 === 1) { + v = two$i64_i64_i64_ops_Mul_mul_i64_i64((a062: rt.i64, a154: rt.i64): rt.i64 => { + return rt.i64Mul(a062, a154); + }, a, b); + } else { + v = ((a061: rt.i64, a153: rt.i64): rt.i64 => { + return rt.i64Mul(a061, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.i64Div(a, b); + } else if (_41 === 1) { + v = two$i64_i64_i64_ops_Div_div_i64_i64((a060: rt.i64, a152: rt.i64): rt.i64 => { + return rt.i64Div(a060, a152); + }, a, b); + } else { + v = ((a059: rt.i64, a151: rt.i64): rt.i64 => { + return rt.i64Div(a059, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.i64Rem(a, b); + } else if (_44 === 1) { + v = two$i64_i64_i64_ops_Rem_rem_i64_i64((a058: rt.i64, a150: rt.i64): rt.i64 => { + return rt.i64Rem(a058, a150); + }, a, b); + } else { + v = ((a057: rt.i64, a149: rt.i64): rt.i64 => { + return rt.i64Rem(a057, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = rt.i64And(a, b); + } else if (_47 === 1) { + v = two$i64_i64_i64_ops_BitAnd_bitand_i64_i64((a056: rt.i64, a148: rt.i64): rt.i64 => { + return rt.i64And(a056, a148); + }, a, b); + } else { + v = ((a055: rt.i64, a147: rt.i64): rt.i64 => { + return rt.i64And(a055, a147); + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = rt.i64Or(a, b); + } else if (_50 === 1) { + v = two$i64_i64_i64_ops_BitOr_bitor_i64_i64((a054: rt.i64, a146: rt.i64): rt.i64 => { + return rt.i64Or(a054, a146); + }, a, b); + } else { + v = ((a053: rt.i64, a145: rt.i64): rt.i64 => { + return rt.i64Or(a053, a145); + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = rt.i64Xor(a, b); + } else if (_53 === 1) { + v = two$i64_i64_i64_ops_BitXor_bitxor_i64_i64((a052: rt.i64, a144: rt.i64): rt.i64 => { + return rt.i64Xor(a052, a144); + }, a, b); + } else { + v = ((a051: rt.i64, a143: rt.i64): rt.i64 => { + return rt.i64Xor(a051, a143); + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.i64Shl(a, n); + } else if (_56 === 1) { + v = two$i64_u32_i64_ops_Shl_shl_i64_u32((a050: rt.i64, a142: rt.u32): rt.i64 => { + return rt.i64Shl(a050, a142); + }, a, n); + } else { + v = ((a049: rt.i64, a141: rt.u32): rt.i64 => { + return rt.i64Shl(a049, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.i64Shr(a, n); + } else if (_59 === 1) { + v = two$i64_u32_i64_ops_Shr_shr_i64_u32((a048: rt.i64, a140: rt.u32): rt.i64 => { + return rt.i64Shr(a048, a140); + }, a, n); + } else { + v = ((a047: rt.i64, a139: rt.u32): rt.i64 => { + return rt.i64Shr(a047, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.i64Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$i64_i16_i64_ops_Shl_shl_i64_i16((a046: rt.i64, a138: rt.i16): rt.i64 => { + return rt.i64Shl(a046, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a045: rt.i64, a137: rt.i16): rt.i64 => { + return rt.i64Shl(a045, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.i64Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$i64_u128_i64_ops_Shr_shr_i64_u128((a044: rt.i64, a136: rt.u128): rt.i64 => { + return rt.i64Shr(a044, a136); + }, a, _74); + } else { + v = ((a043: rt.i64, a135: rt.u128): rt.i64 => { + return rt.i64Shr(a043, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = rt.i64Not(a); + } else if (_83 === 1) { + v = one$i64_i64_ops_Not_not_i64((a042: rt.i64): rt.i64 => { + return rt.i64Not(a042); + }, a); + } else { + v = ((a041: rt.i64): rt.i64 => { + return rt.i64Not(a041); + })(a); + } + } else if (_30 === 13) { + if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { + const _92: rt.u8 = rt.u8Rem(form, 3); + if (_92 === 0) { + _87 = rt.i64Neg(a); + } else if (_92 === 1) { + _87 = one$i64_i64_ops_Neg_neg_i64((a040: rt.i64): rt.i64 => { + return rt.i64Neg(a040); + }, a); + } else { + _87 = ((a039: rt.i64): rt.i64 => { + return rt.i64Neg(a039); + })(a); + } + } else { + const _95: rt.u8 = rt.u8Rem(form, 3); + if (_95 === 0) { + _87 = rt.i64Neg(a); + } else if (_95 === 1) { + _87 = one$ref_i64_i64_ops_Neg_neg_ref_i64((a038: rt.i64): rt.i64 => { + return rt.i64Neg(a038); + }, a); + } else { + _87 = ((a037: rt.i64): rt.i64 => { + return rt.i64Neg(a037); + })(a); + } + } + const _86: rt.i64 | undefined = _87; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.i64 = a; + const _105: rt.u8 = rt.u8Rem(form, 3); + if (_105 === 0) { + x = rt.i64Add(x, b); + } else if (_105 === 1) { + two$mut_i64_i64_unit_ops_AddAssign_add_assign_i64_i64((a036: rt.Place, a134: rt.i64): undefined => { + a036.v = rt.i64Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.i64): undefined => { + a035.v = rt.i64Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.i64 = a; + const _113: rt.u8 = rt.u8Rem(form, 3); + if (_113 === 0) { + x2 = rt.i64Sub(x2, b); + } else if (_113 === 1) { + two$mut_i64_i64_unit_ops_SubAssign_sub_assign_i64_i64((a034: rt.Place, a132: rt.i64): undefined => { + a034.v = rt.i64Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.i64): undefined => { + a033.v = rt.i64Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.i64 = a; + const _121: rt.u8 = rt.u8Rem(form, 3); + if (_121 === 0) { + x3 = rt.i64Mul(x3, b); + } else if (_121 === 1) { + two$mut_i64_i64_unit_ops_MulAssign_mul_assign_i64_i64((a032: rt.Place, a130: rt.i64): undefined => { + a032.v = rt.i64Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.i64): undefined => { + a031.v = rt.i64Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.i64 = a; + const _129: rt.u8 = rt.u8Rem(form, 3); + if (_129 === 0) { + x4 = rt.i64Div(x4, b); + } else if (_129 === 1) { + two$mut_i64_i64_unit_ops_DivAssign_div_assign_i64_i64((a030: rt.Place, a128: rt.i64): undefined => { + a030.v = rt.i64Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.i64): undefined => { + a029.v = rt.i64Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.i64 = a; + const _137: rt.u8 = rt.u8Rem(form, 3); + if (_137 === 0) { + x5 = rt.i64Rem(x5, b); + } else if (_137 === 1) { + two$mut_i64_i64_unit_ops_RemAssign_rem_assign_i64_i64((a028: rt.Place, a126: rt.i64): undefined => { + a028.v = rt.i64Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.i64): undefined => { + a027.v = rt.i64Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.i64 = a; + const _145: rt.u8 = rt.u8Rem(form, 3); + if (_145 === 0) { + x6 = rt.i64And(x6, b); + } else if (_145 === 1) { + two$mut_i64_i64_unit_ops_BitAndAssign_bitand_assign_i64_i64((a026: rt.Place, a124: rt.i64): undefined => { + a026.v = rt.i64And(a026.v, a124); + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.i64): undefined => { + a025.v = rt.i64And(a025.v, a123); + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.i64 = a; + const _153: rt.u8 = rt.u8Rem(form, 3); + if (_153 === 0) { + x7 = rt.i64Or(x7, b); + } else if (_153 === 1) { + two$mut_i64_i64_unit_ops_BitOrAssign_bitor_assign_i64_i64((a024: rt.Place, a122: rt.i64): undefined => { + a024.v = rt.i64Or(a024.v, a122); + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.i64): undefined => { + a023.v = rt.i64Or(a023.v, a121); + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.i64 = a; + const _161: rt.u8 = rt.u8Rem(form, 3); + if (_161 === 0) { + x8 = rt.i64Xor(x8, b); + } else if (_161 === 1) { + two$mut_i64_i64_unit_ops_BitXorAssign_bitxor_assign_i64_i64((a022: rt.Place, a120: rt.i64): undefined => { + a022.v = rt.i64Xor(a022.v, a120); + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.i64): undefined => { + a021.v = rt.i64Xor(a021.v, a119); + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.i64 = a; + const _169: rt.u8 = rt.u8Rem(form, 3); + if (_169 === 0) { + x9 = rt.i64Shl(x9, n); + } else if (_169 === 1) { + two$mut_i64_u32_unit_ops_ShlAssign_shl_assign_i64_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.i64Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.i64Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.i64 = a; + const _177: rt.u8 = rt.u8Rem(form, 3); + if (_177 === 0) { + x10 = rt.i64Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_177 === 1) { + two$mut_i64_i64_unit_ops_ShrAssign_shr_assign_i64_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.i64Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.i64Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _189: rt.u8 = rt.u8Rem(form, 3); + if (_189 === 0) { + v = rt.i64Add(a, b); + } else if (_189 === 1) { + v = two$i64_ref_i64_i64_ops_Add_add_i64_ref_i64((a016: rt.i64, a114: rt.i64): rt.i64 => { + return rt.i64Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.i64, a113: rt.i64): rt.i64 => { + return rt.i64Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _195: rt.u8 = rt.u8Rem(form, 3); + if (_195 === 0) { + v = rt.i64Sub(a, b); + } else if (_195 === 1) { + v = two$ref_i64_i64_i64_ops_Sub_sub_ref_i64_i64((a014: rt.i64, a112: rt.i64): rt.i64 => { + return rt.i64Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.i64, a111: rt.i64): rt.i64 => { + return rt.i64Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _201: rt.u8 = rt.u8Rem(form, 3); + if (_201 === 0) { + v = rt.i64Mul(a, b); + } else if (_201 === 1) { + v = two$ref_i64_ref_i64_i64_ops_Mul_mul_ref_i64_ref_i64((a012: rt.i64, a110: rt.i64): rt.i64 => { + return rt.i64Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.i64, a19: rt.i64): rt.i64 => { + return rt.i64Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _210: rt.u8 = rt.u8Rem(form, 3); + if (_210 === 0) { + v = rt.i64Shl(a, n & 0xff); + } else if (_210 === 1) { + v = two$ref_i64_ref_u8_i64_ops_Shl_shl_ref_i64_ref_u8((a010: rt.i64, a18: rt.u8): rt.i64 => { + return rt.i64Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.i64, a17: rt.u8): rt.i64 => { + return rt.i64Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _222: rt.u8 = rt.u8Rem(form, 3); + if (_222 === 0) { + v = rt.i64Not(a); + } else if (_222 === 1) { + v = one$ref_i64_i64_ops_Not_not_ref_i64((a08: rt.i64): rt.i64 => { + return rt.i64Not(a08); + }, a); + } else { + v = ((a07: rt.i64): rt.i64 => { + return rt.i64Not(a07); + })(a); + } + } else if (_30 === 29) { + let x11: rt.i64 = a; + const _230: rt.u8 = rt.u8Rem(form, 3); + if (_230 === 0) { + x11 = rt.i64Add(x11, b); + } else if (_230 === 1) { + two$mut_i64_ref_i64_unit_ops_AddAssign_add_assign_i64_ref_i64((a06: rt.Place, a16: rt.i64): undefined => { + a06.v = rt.i64Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.i64): undefined => { + a05.v = rt.i64Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.i64 = a; + const _241: rt.u8 = rt.u8Rem(form, 3); + if (_241 === 0) { + x12 = rt.i64Div(x12, b); + } else if (_241 === 1) { + two$mut_i64_ref_i64_unit_ops_DivAssign_div_assign_i64_ref_i64((a04: rt.Place, a14: rt.i64): undefined => { + a04.v = rt.i64Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.i64): undefined => { + a03.v = rt.i64Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.i64 = a; + const _252: rt.u8 = rt.u8Rem(form, 3); + if (_252 === 0) { + x13 = rt.i64Shr(x13, n & 0xffff); + } else if (_252 === 1) { + two$mut_i64_ref_u16_unit_ops_ShrAssign_shr_assign_i64_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.i64Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i64Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.i128; + let _87!: rt.i128; + const _28: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v3: rt.i128): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3))); + }; + const take: (a0: rt.usize) => rt.i128 = (at: rt.usize): rt.i128 => { + const buf: Uint8Array = rt.bytes(16); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.i128FromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.i128, rt.i128] = [take(1), take(1 + 16)]; + const a: rt.i128 = _10[0]; + const b: rt.i128 = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 16), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.i128Add(a, b); + } else if (_32 === 1) { + v = two$i128_i128_i128_ops_Add_add_i128_i128((a066: rt.i128, a158: rt.i128): rt.i128 => { + return rt.i128Add(a066, a158); + }, a, b); + } else { + v = ((a065: rt.i128, a157: rt.i128): rt.i128 => { + return rt.i128Add(a065, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.i128Sub(a, b); + } else if (_35 === 1) { + v = two$i128_i128_i128_ops_Sub_sub_i128_i128((a064: rt.i128, a156: rt.i128): rt.i128 => { + return rt.i128Sub(a064, a156); + }, a, b); + } else { + v = ((a063: rt.i128, a155: rt.i128): rt.i128 => { + return rt.i128Sub(a063, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.i128Mul(a, b); + } else if (_38 === 1) { + v = two$i128_i128_i128_ops_Mul_mul_i128_i128((a062: rt.i128, a154: rt.i128): rt.i128 => { + return rt.i128Mul(a062, a154); + }, a, b); + } else { + v = ((a061: rt.i128, a153: rt.i128): rt.i128 => { + return rt.i128Mul(a061, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.i128Div(a, b); + } else if (_41 === 1) { + v = two$i128_i128_i128_ops_Div_div_i128_i128((a060: rt.i128, a152: rt.i128): rt.i128 => { + return rt.i128Div(a060, a152); + }, a, b); + } else { + v = ((a059: rt.i128, a151: rt.i128): rt.i128 => { + return rt.i128Div(a059, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.i128Rem(a, b); + } else if (_44 === 1) { + v = two$i128_i128_i128_ops_Rem_rem_i128_i128((a058: rt.i128, a150: rt.i128): rt.i128 => { + return rt.i128Rem(a058, a150); + }, a, b); + } else { + v = ((a057: rt.i128, a149: rt.i128): rt.i128 => { + return rt.i128Rem(a057, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = rt.i128And(a, b); + } else if (_47 === 1) { + v = two$i128_i128_i128_ops_BitAnd_bitand_i128_i128((a056: rt.i128, a148: rt.i128): rt.i128 => { + return rt.i128And(a056, a148); + }, a, b); + } else { + v = ((a055: rt.i128, a147: rt.i128): rt.i128 => { + return rt.i128And(a055, a147); + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = rt.i128Or(a, b); + } else if (_50 === 1) { + v = two$i128_i128_i128_ops_BitOr_bitor_i128_i128((a054: rt.i128, a146: rt.i128): rt.i128 => { + return rt.i128Or(a054, a146); + }, a, b); + } else { + v = ((a053: rt.i128, a145: rt.i128): rt.i128 => { + return rt.i128Or(a053, a145); + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = rt.i128Xor(a, b); + } else if (_53 === 1) { + v = two$i128_i128_i128_ops_BitXor_bitxor_i128_i128((a052: rt.i128, a144: rt.i128): rt.i128 => { + return rt.i128Xor(a052, a144); + }, a, b); + } else { + v = ((a051: rt.i128, a143: rt.i128): rt.i128 => { + return rt.i128Xor(a051, a143); + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.i128Shl(a, n); + } else if (_56 === 1) { + v = two$i128_u32_i128_ops_Shl_shl_i128_u32((a050: rt.i128, a142: rt.u32): rt.i128 => { + return rt.i128Shl(a050, a142); + }, a, n); + } else { + v = ((a049: rt.i128, a141: rt.u32): rt.i128 => { + return rt.i128Shl(a049, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.i128Shr(a, n); + } else if (_59 === 1) { + v = two$i128_u32_i128_ops_Shr_shr_i128_u32((a048: rt.i128, a140: rt.u32): rt.i128 => { + return rt.i128Shr(a048, a140); + }, a, n); + } else { + v = ((a047: rt.i128, a139: rt.u32): rt.i128 => { + return rt.i128Shr(a047, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.i128Shl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$i128_i16_i128_ops_Shl_shl_i128_i16((a046: rt.i128, a138: rt.i16): rt.i128 => { + return rt.i128Shl(a046, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a045: rt.i128, a137: rt.i16): rt.i128 => { + return rt.i128Shl(a045, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.i128Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$i128_u128_i128_ops_Shr_shr_i128_u128((a044: rt.i128, a136: rt.u128): rt.i128 => { + return rt.i128Shr(a044, a136); + }, a, _74); + } else { + v = ((a043: rt.i128, a135: rt.u128): rt.i128 => { + return rt.i128Shr(a043, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = rt.i128Not(a); + } else if (_83 === 1) { + v = one$i128_i128_ops_Not_not_i128((a042: rt.i128): rt.i128 => { + return rt.i128Not(a042); + }, a); + } else { + v = ((a041: rt.i128): rt.i128 => { + return rt.i128Not(a041); + })(a); + } + } else if (_30 === 13) { + if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { + const _92: rt.u8 = rt.u8Rem(form, 3); + if (_92 === 0) { + _87 = rt.i128Neg(a); + } else if (_92 === 1) { + _87 = one$i128_i128_ops_Neg_neg_i128((a040: rt.i128): rt.i128 => { + return rt.i128Neg(a040); + }, a); + } else { + _87 = ((a039: rt.i128): rt.i128 => { + return rt.i128Neg(a039); + })(a); + } + } else { + const _95: rt.u8 = rt.u8Rem(form, 3); + if (_95 === 0) { + _87 = rt.i128Neg(a); + } else if (_95 === 1) { + _87 = one$ref_i128_i128_ops_Neg_neg_ref_i128((a038: rt.i128): rt.i128 => { + return rt.i128Neg(a038); + }, a); + } else { + _87 = ((a037: rt.i128): rt.i128 => { + return rt.i128Neg(a037); + })(a); + } + } + const _86: rt.i128 | undefined = _87; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.i128 = a; + const _105: rt.u8 = rt.u8Rem(form, 3); + if (_105 === 0) { + x = rt.i128Add(x, b); + } else if (_105 === 1) { + two$mut_i128_i128_unit_ops_AddAssign_add_assign_i128_i128((a036: rt.Place, a134: rt.i128): undefined => { + a036.v = rt.i128Add(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.i128): undefined => { + a035.v = rt.i128Add(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.i128 = a; + const _113: rt.u8 = rt.u8Rem(form, 3); + if (_113 === 0) { + x2 = rt.i128Sub(x2, b); + } else if (_113 === 1) { + two$mut_i128_i128_unit_ops_SubAssign_sub_assign_i128_i128((a034: rt.Place, a132: rt.i128): undefined => { + a034.v = rt.i128Sub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.i128): undefined => { + a033.v = rt.i128Sub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.i128 = a; + const _121: rt.u8 = rt.u8Rem(form, 3); + if (_121 === 0) { + x3 = rt.i128Mul(x3, b); + } else if (_121 === 1) { + two$mut_i128_i128_unit_ops_MulAssign_mul_assign_i128_i128((a032: rt.Place, a130: rt.i128): undefined => { + a032.v = rt.i128Mul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.i128): undefined => { + a031.v = rt.i128Mul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.i128 = a; + const _129: rt.u8 = rt.u8Rem(form, 3); + if (_129 === 0) { + x4 = rt.i128Div(x4, b); + } else if (_129 === 1) { + two$mut_i128_i128_unit_ops_DivAssign_div_assign_i128_i128((a030: rt.Place, a128: rt.i128): undefined => { + a030.v = rt.i128Div(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.i128): undefined => { + a029.v = rt.i128Div(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.i128 = a; + const _137: rt.u8 = rt.u8Rem(form, 3); + if (_137 === 0) { + x5 = rt.i128Rem(x5, b); + } else if (_137 === 1) { + two$mut_i128_i128_unit_ops_RemAssign_rem_assign_i128_i128((a028: rt.Place, a126: rt.i128): undefined => { + a028.v = rt.i128Rem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.i128): undefined => { + a027.v = rt.i128Rem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.i128 = a; + const _145: rt.u8 = rt.u8Rem(form, 3); + if (_145 === 0) { + x6 = rt.i128And(x6, b); + } else if (_145 === 1) { + two$mut_i128_i128_unit_ops_BitAndAssign_bitand_assign_i128_i128((a026: rt.Place, a124: rt.i128): undefined => { + a026.v = rt.i128And(a026.v, a124); + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.i128): undefined => { + a025.v = rt.i128And(a025.v, a123); + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.i128 = a; + const _153: rt.u8 = rt.u8Rem(form, 3); + if (_153 === 0) { + x7 = rt.i128Or(x7, b); + } else if (_153 === 1) { + two$mut_i128_i128_unit_ops_BitOrAssign_bitor_assign_i128_i128((a024: rt.Place, a122: rt.i128): undefined => { + a024.v = rt.i128Or(a024.v, a122); + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.i128): undefined => { + a023.v = rt.i128Or(a023.v, a121); + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.i128 = a; + const _161: rt.u8 = rt.u8Rem(form, 3); + if (_161 === 0) { + x8 = rt.i128Xor(x8, b); + } else if (_161 === 1) { + two$mut_i128_i128_unit_ops_BitXorAssign_bitxor_assign_i128_i128((a022: rt.Place, a120: rt.i128): undefined => { + a022.v = rt.i128Xor(a022.v, a120); + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.i128): undefined => { + a021.v = rt.i128Xor(a021.v, a119); + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.i128 = a; + const _169: rt.u8 = rt.u8Rem(form, 3); + if (_169 === 0) { + x9 = rt.i128Shl(x9, n); + } else if (_169 === 1) { + two$mut_i128_u32_unit_ops_ShlAssign_shl_assign_i128_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.i128Shl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.i128Shl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.i128 = a; + const _177: rt.u8 = rt.u8Rem(form, 3); + if (_177 === 0) { + x10 = rt.i128Shr(x10, (n << 16) >> 16 as rt.i64); + } else if (_177 === 1) { + two$mut_i128_i64_unit_ops_ShrAssign_shr_assign_i128_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.i128Shr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.i128Shr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _189: rt.u8 = rt.u8Rem(form, 3); + if (_189 === 0) { + v = rt.i128Add(a, b); + } else if (_189 === 1) { + v = two$i128_ref_i128_i128_ops_Add_add_i128_ref_i128((a016: rt.i128, a114: rt.i128): rt.i128 => { + return rt.i128Add(a016, a114); + }, a, b); + } else { + v = ((a015: rt.i128, a113: rt.i128): rt.i128 => { + return rt.i128Add(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _195: rt.u8 = rt.u8Rem(form, 3); + if (_195 === 0) { + v = rt.i128Sub(a, b); + } else if (_195 === 1) { + v = two$ref_i128_i128_i128_ops_Sub_sub_ref_i128_i128((a014: rt.i128, a112: rt.i128): rt.i128 => { + return rt.i128Sub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.i128, a111: rt.i128): rt.i128 => { + return rt.i128Sub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _201: rt.u8 = rt.u8Rem(form, 3); + if (_201 === 0) { + v = rt.i128Mul(a, b); + } else if (_201 === 1) { + v = two$ref_i128_ref_i128_i128_ops_Mul_mul_ref_i128_ref_i128((a012: rt.i128, a110: rt.i128): rt.i128 => { + return rt.i128Mul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.i128, a19: rt.i128): rt.i128 => { + return rt.i128Mul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _210: rt.u8 = rt.u8Rem(form, 3); + if (_210 === 0) { + v = rt.i128Shl(a, n & 0xff); + } else if (_210 === 1) { + v = two$ref_i128_ref_u8_i128_ops_Shl_shl_ref_i128_ref_u8((a010: rt.i128, a18: rt.u8): rt.i128 => { + return rt.i128Shl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.i128, a17: rt.u8): rt.i128 => { + return rt.i128Shl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _222: rt.u8 = rt.u8Rem(form, 3); + if (_222 === 0) { + v = rt.i128Not(a); + } else if (_222 === 1) { + v = one$ref_i128_i128_ops_Not_not_ref_i128((a08: rt.i128): rt.i128 => { + return rt.i128Not(a08); + }, a); + } else { + v = ((a07: rt.i128): rt.i128 => { + return rt.i128Not(a07); + })(a); + } + } else if (_30 === 29) { + let x11: rt.i128 = a; + const _230: rt.u8 = rt.u8Rem(form, 3); + if (_230 === 0) { + x11 = rt.i128Add(x11, b); + } else if (_230 === 1) { + two$mut_i128_ref_i128_unit_ops_AddAssign_add_assign_i128_ref_i128((a06: rt.Place, a16: rt.i128): undefined => { + a06.v = rt.i128Add(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.i128): undefined => { + a05.v = rt.i128Add(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.i128 = a; + const _241: rt.u8 = rt.u8Rem(form, 3); + if (_241 === 0) { + x12 = rt.i128Div(x12, b); + } else if (_241 === 1) { + two$mut_i128_ref_i128_unit_ops_DivAssign_div_assign_i128_ref_i128((a04: rt.Place, a14: rt.i128): undefined => { + a04.v = rt.i128Div(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.i128): undefined => { + a03.v = rt.i128Div(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.i128 = a; + const _252: rt.u8 = rt.u8Rem(form, 3); + if (_252 === 0) { + x13 = rt.i128Shr(x13, n & 0xffff); + } else if (_252 === 1) { + two$mut_i128_ref_u16_unit_ops_ShrAssign_shr_assign_i128_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.i128Shr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.i128Shr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to operands taken from `data`, in the form its first byte + * picks: two operands, then a shift amount, which may pass the width many times over. + */ +export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.isize; + let _87!: rt.isize; + const _28: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v3: rt.isize): undefined => { + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); + }; + const take: (a0: rt.usize) => rt.isize = (at: rt.usize): rt.isize => { + const buf: Uint8Array = rt.bytes(4); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_102 === rt.DONE) { + break; + } + _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + } + return rt.isizeFromBeBytes(buf); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.isize, rt.isize] = [take(1), take(1 + 4)]; + const a: rt.isize = _10[0]; + const b: rt.isize = _10[1]; + const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 4), i2)), 0); + }; + const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + b0: { + const _30: rt.u8 = rt.u8Rem(kind, 32); + if (_30 === 0) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = rt.isizeAdd(a, b); + } else if (_32 === 1) { + v = two$isize_isize_isize_ops_Add_add_isize_isize((a066: rt.isize, a158: rt.isize): rt.isize => { + return rt.isizeAdd(a066, a158); + }, a, b); + } else { + v = ((a065: rt.isize, a157: rt.isize): rt.isize => { + return rt.isizeAdd(a065, a157); + })(a, b); + } + } else if (_30 === 1) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = rt.isizeSub(a, b); + } else if (_35 === 1) { + v = two$isize_isize_isize_ops_Sub_sub_isize_isize((a064: rt.isize, a156: rt.isize): rt.isize => { + return rt.isizeSub(a064, a156); + }, a, b); + } else { + v = ((a063: rt.isize, a155: rt.isize): rt.isize => { + return rt.isizeSub(a063, a155); + })(a, b); + } + } else if (_30 === 2) { + const _38: rt.u8 = rt.u8Rem(form, 3); + if (_38 === 0) { + v = rt.isizeMul(a, b); + } else if (_38 === 1) { + v = two$isize_isize_isize_ops_Mul_mul_isize_isize((a062: rt.isize, a154: rt.isize): rt.isize => { + return rt.isizeMul(a062, a154); + }, a, b); + } else { + v = ((a061: rt.isize, a153: rt.isize): rt.isize => { + return rt.isizeMul(a061, a153); + })(a, b); + } + } else if (_30 === 3) { + const _41: rt.u8 = rt.u8Rem(form, 3); + if (_41 === 0) { + v = rt.isizeDiv(a, b); + } else if (_41 === 1) { + v = two$isize_isize_isize_ops_Div_div_isize_isize((a060: rt.isize, a152: rt.isize): rt.isize => { + return rt.isizeDiv(a060, a152); + }, a, b); + } else { + v = ((a059: rt.isize, a151: rt.isize): rt.isize => { + return rt.isizeDiv(a059, a151); + })(a, b); + } + } else if (_30 === 4) { + const _44: rt.u8 = rt.u8Rem(form, 3); + if (_44 === 0) { + v = rt.isizeRem(a, b); + } else if (_44 === 1) { + v = two$isize_isize_isize_ops_Rem_rem_isize_isize((a058: rt.isize, a150: rt.isize): rt.isize => { + return rt.isizeRem(a058, a150); + }, a, b); + } else { + v = ((a057: rt.isize, a149: rt.isize): rt.isize => { + return rt.isizeRem(a057, a149); + })(a, b); + } + } else if (_30 === 5) { + const _47: rt.u8 = rt.u8Rem(form, 3); + if (_47 === 0) { + v = a & b; + } else if (_47 === 1) { + v = two$isize_isize_isize_ops_BitAnd_bitand_isize_isize((a056: rt.isize, a148: rt.isize): rt.isize => { + return a056 & a148; + }, a, b); + } else { + v = ((a055: rt.isize, a147: rt.isize): rt.isize => { + return a055 & a147; + })(a, b); + } + } else if (_30 === 6) { + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + v = a | b; + } else if (_50 === 1) { + v = two$isize_isize_isize_ops_BitOr_bitor_isize_isize((a054: rt.isize, a146: rt.isize): rt.isize => { + return a054 | a146; + }, a, b); + } else { + v = ((a053: rt.isize, a145: rt.isize): rt.isize => { + return a053 | a145; + })(a, b); + } + } else if (_30 === 7) { + const _53: rt.u8 = rt.u8Rem(form, 3); + if (_53 === 0) { + v = a ^ b; + } else if (_53 === 1) { + v = two$isize_isize_isize_ops_BitXor_bitxor_isize_isize((a052: rt.isize, a144: rt.isize): rt.isize => { + return a052 ^ a144; + }, a, b); + } else { + v = ((a051: rt.isize, a143: rt.isize): rt.isize => { + return a051 ^ a143; + })(a, b); + } + } else if (_30 === 8) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = rt.isizeShl(a, n); + } else if (_56 === 1) { + v = two$isize_u32_isize_ops_Shl_shl_isize_u32((a050: rt.isize, a142: rt.u32): rt.isize => { + return rt.isizeShl(a050, a142); + }, a, n); + } else { + v = ((a049: rt.isize, a141: rt.u32): rt.isize => { + return rt.isizeShl(a049, a141); + })(a, n); + } + } else if (_30 === 9) { + const _59: rt.u8 = rt.u8Rem(form, 3); + if (_59 === 0) { + v = rt.isizeShr(a, n); + } else if (_59 === 1) { + v = two$isize_u32_isize_ops_Shr_shr_isize_u32((a048: rt.isize, a140: rt.u32): rt.isize => { + return rt.isizeShr(a048, a140); + }, a, n); + } else { + v = ((a047: rt.isize, a139: rt.u32): rt.isize => { + return rt.isizeShr(a047, a139); + })(a, n); + } + } else if (_30 === 10) { + const _62: rt.u8 = rt.u8Rem(form, 3); + if (_62 === 0) { + v = rt.isizeShl(a, (n << 16) >> 16); + } else if (_62 === 1) { + v = two$isize_i16_isize_ops_Shl_shl_isize_i16((a046: rt.isize, a138: rt.i16): rt.isize => { + return rt.isizeShl(a046, a138); + }, a, (n << 16) >> 16); + } else { + v = ((a045: rt.isize, a137: rt.i16): rt.isize => { + return rt.isizeShl(a045, a137); + })(a, (n << 16) >> 16); + } + } else if (_30 === 11) { + const _68: rt.u8 = rt.u8Rem(form, 3); + if (_68 === 0) { + v = rt.isizeShr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } else if (_68 === 1) { + const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); + v = two$isize_u128_isize_ops_Shr_shr_isize_u128((a044: rt.isize, a136: rt.u128): rt.isize => { + return rt.isizeShr(a044, a136); + }, a, _74); + } else { + v = ((a043: rt.isize, a135: rt.u128): rt.isize => { + return rt.isizeShr(a043, a135); + })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + } + } else if (_30 === 12) { + const _83: rt.u8 = rt.u8Rem(form, 3); + if (_83 === 0) { + v = ~a; + } else if (_83 === 1) { + v = one$isize_isize_ops_Not_not_isize((a042: rt.isize): rt.isize => { + return ~a042; + }, a); + } else { + v = ((a041: rt.isize): rt.isize => { + return ~a041; + })(a); + } + } else if (_30 === 13) { + if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { + const _92: rt.u8 = rt.u8Rem(form, 3); + if (_92 === 0) { + _87 = rt.isizeNeg(a); + } else if (_92 === 1) { + _87 = one$isize_isize_ops_Neg_neg_isize((a040: rt.isize): rt.isize => { + return rt.isizeNeg(a040); + }, a); + } else { + _87 = ((a039: rt.isize): rt.isize => { + return rt.isizeNeg(a039); + })(a); + } + } else { + const _95: rt.u8 = rt.u8Rem(form, 3); + if (_95 === 0) { + _87 = rt.isizeNeg(a); + } else if (_95 === 1) { + _87 = one$ref_isize_isize_ops_Neg_neg_ref_isize((a038: rt.isize): rt.isize => { + return rt.isizeNeg(a038); + }, a); + } else { + _87 = ((a037: rt.isize): rt.isize => { + return rt.isizeNeg(a037); + })(a); + } + } + const _86: rt.isize | undefined = _87; + if (_86 === undefined) { + break b0; + } + v = _86; + } else if (_30 === 14) { + let x: rt.isize = a; + const _105: rt.u8 = rt.u8Rem(form, 3); + if (_105 === 0) { + x = rt.isizeAdd(x, b); + } else if (_105 === 1) { + two$mut_isize_isize_unit_ops_AddAssign_add_assign_isize_isize((a036: rt.Place, a134: rt.isize): undefined => { + a036.v = rt.isizeAdd(a036.v, a134); + }, rt.place(() => x, (value26) => x = value26), b); + } else { + ((a035: rt.Place, a133: rt.isize): undefined => { + a035.v = rt.isizeAdd(a035.v, a133); + })(rt.place(() => x, (value25) => x = value25), b); + } + v = x; + } else if (_30 === 15) { + let x2: rt.isize = a; + const _113: rt.u8 = rt.u8Rem(form, 3); + if (_113 === 0) { + x2 = rt.isizeSub(x2, b); + } else if (_113 === 1) { + two$mut_isize_isize_unit_ops_SubAssign_sub_assign_isize_isize((a034: rt.Place, a132: rt.isize): undefined => { + a034.v = rt.isizeSub(a034.v, a132); + }, rt.place(() => x2, (value24) => x2 = value24), b); + } else { + ((a033: rt.Place, a131: rt.isize): undefined => { + a033.v = rt.isizeSub(a033.v, a131); + })(rt.place(() => x2, (value23) => x2 = value23), b); + } + v = x2; + } else if (_30 === 16) { + let x3: rt.isize = a; + const _121: rt.u8 = rt.u8Rem(form, 3); + if (_121 === 0) { + x3 = rt.isizeMul(x3, b); + } else if (_121 === 1) { + two$mut_isize_isize_unit_ops_MulAssign_mul_assign_isize_isize((a032: rt.Place, a130: rt.isize): undefined => { + a032.v = rt.isizeMul(a032.v, a130); + }, rt.place(() => x3, (value22) => x3 = value22), b); + } else { + ((a031: rt.Place, a129: rt.isize): undefined => { + a031.v = rt.isizeMul(a031.v, a129); + })(rt.place(() => x3, (value21) => x3 = value21), b); + } + v = x3; + } else if (_30 === 17) { + let x4: rt.isize = a; + const _129: rt.u8 = rt.u8Rem(form, 3); + if (_129 === 0) { + x4 = rt.isizeDiv(x4, b); + } else if (_129 === 1) { + two$mut_isize_isize_unit_ops_DivAssign_div_assign_isize_isize((a030: rt.Place, a128: rt.isize): undefined => { + a030.v = rt.isizeDiv(a030.v, a128); + }, rt.place(() => x4, (value20) => x4 = value20), b); + } else { + ((a029: rt.Place, a127: rt.isize): undefined => { + a029.v = rt.isizeDiv(a029.v, a127); + })(rt.place(() => x4, (value19) => x4 = value19), b); + } + v = x4; + } else if (_30 === 18) { + let x5: rt.isize = a; + const _137: rt.u8 = rt.u8Rem(form, 3); + if (_137 === 0) { + x5 = rt.isizeRem(x5, b); + } else if (_137 === 1) { + two$mut_isize_isize_unit_ops_RemAssign_rem_assign_isize_isize((a028: rt.Place, a126: rt.isize): undefined => { + a028.v = rt.isizeRem(a028.v, a126); + }, rt.place(() => x5, (value18) => x5 = value18), b); + } else { + ((a027: rt.Place, a125: rt.isize): undefined => { + a027.v = rt.isizeRem(a027.v, a125); + })(rt.place(() => x5, (value17) => x5 = value17), b); + } + v = x5; + } else if (_30 === 19) { + let x6: rt.isize = a; + const _145: rt.u8 = rt.u8Rem(form, 3); + if (_145 === 0) { + x6 = x6 & b; + } else if (_145 === 1) { + two$mut_isize_isize_unit_ops_BitAndAssign_bitand_assign_isize_isize((a026: rt.Place, a124: rt.isize): undefined => { + a026.v = a026.v & a124; + }, rt.place(() => x6, (value16) => x6 = value16), b); + } else { + ((a025: rt.Place, a123: rt.isize): undefined => { + a025.v = a025.v & a123; + })(rt.place(() => x6, (value15) => x6 = value15), b); + } + v = x6; + } else if (_30 === 20) { + let x7: rt.isize = a; + const _153: rt.u8 = rt.u8Rem(form, 3); + if (_153 === 0) { + x7 = x7 | b; + } else if (_153 === 1) { + two$mut_isize_isize_unit_ops_BitOrAssign_bitor_assign_isize_isize((a024: rt.Place, a122: rt.isize): undefined => { + a024.v = a024.v | a122; + }, rt.place(() => x7, (value14) => x7 = value14), b); + } else { + ((a023: rt.Place, a121: rt.isize): undefined => { + a023.v = a023.v | a121; + })(rt.place(() => x7, (value13) => x7 = value13), b); + } + v = x7; + } else if (_30 === 21) { + let x8: rt.isize = a; + const _161: rt.u8 = rt.u8Rem(form, 3); + if (_161 === 0) { + x8 = x8 ^ b; + } else if (_161 === 1) { + two$mut_isize_isize_unit_ops_BitXorAssign_bitxor_assign_isize_isize((a022: rt.Place, a120: rt.isize): undefined => { + a022.v = a022.v ^ a120; + }, rt.place(() => x8, (value12) => x8 = value12), b); + } else { + ((a021: rt.Place, a119: rt.isize): undefined => { + a021.v = a021.v ^ a119; + })(rt.place(() => x8, (value11) => x8 = value11), b); + } + v = x8; + } else if (_30 === 22) { + let x9: rt.isize = a; + const _169: rt.u8 = rt.u8Rem(form, 3); + if (_169 === 0) { + x9 = rt.isizeShl(x9, n); + } else if (_169 === 1) { + two$mut_isize_u32_unit_ops_ShlAssign_shl_assign_isize_u32((a020: rt.Place, a118: rt.u32): undefined => { + a020.v = rt.isizeShl(a020.v, a118); + }, rt.place(() => x9, (value10) => x9 = value10), n); + } else { + ((a019: rt.Place, a117: rt.u32): undefined => { + a019.v = rt.isizeShl(a019.v, a117); + })(rt.place(() => x9, (value9) => x9 = value9), n); + } + v = x9; + } else if (_30 === 23) { + let x10: rt.isize = a; + const _177: rt.u8 = rt.u8Rem(form, 3); + if (_177 === 0) { + x10 = rt.isizeShr(x10, (n << 16) >> 16 as rt.i64); + } else if (_177 === 1) { + two$mut_isize_i64_unit_ops_ShrAssign_shr_assign_isize_i64((a018: rt.Place, a116: rt.i64): undefined => { + a018.v = rt.isizeShr(a018.v, a116); + }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + } else { + ((a017: rt.Place, a115: rt.i64): undefined => { + a017.v = rt.isizeShr(a017.v, a115); + })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + } + v = x10; + } else if (_30 === 24) { + const _189: rt.u8 = rt.u8Rem(form, 3); + if (_189 === 0) { + v = rt.isizeAdd(a, b); + } else if (_189 === 1) { + v = two$isize_ref_isize_isize_ops_Add_add_isize_ref_isize((a016: rt.isize, a114: rt.isize): rt.isize => { + return rt.isizeAdd(a016, a114); + }, a, b); + } else { + v = ((a015: rt.isize, a113: rt.isize): rt.isize => { + return rt.isizeAdd(a015, a113); + })(a, b); + } + } else if (_30 === 25) { + const _195: rt.u8 = rt.u8Rem(form, 3); + if (_195 === 0) { + v = rt.isizeSub(a, b); + } else if (_195 === 1) { + v = two$ref_isize_isize_isize_ops_Sub_sub_ref_isize_isize((a014: rt.isize, a112: rt.isize): rt.isize => { + return rt.isizeSub(a014, a112); + }, a, b); + } else { + v = ((a013: rt.isize, a111: rt.isize): rt.isize => { + return rt.isizeSub(a013, a111); + })(a, b); + } + } else if (_30 === 26) { + const _201: rt.u8 = rt.u8Rem(form, 3); + if (_201 === 0) { + v = rt.isizeMul(a, b); + } else if (_201 === 1) { + v = two$ref_isize_ref_isize_isize_ops_Mul_mul_ref_isize_ref_isize((a012: rt.isize, a110: rt.isize): rt.isize => { + return rt.isizeMul(a012, a110); + }, a, b); + } else { + v = ((a011: rt.isize, a19: rt.isize): rt.isize => { + return rt.isizeMul(a011, a19); + })(a, b); + } + } else if (_30 === 27) { + const _210: rt.u8 = rt.u8Rem(form, 3); + if (_210 === 0) { + v = rt.isizeShl(a, n & 0xff); + } else if (_210 === 1) { + v = two$ref_isize_ref_u8_isize_ops_Shl_shl_ref_isize_ref_u8((a010: rt.isize, a18: rt.u8): rt.isize => { + return rt.isizeShl(a010, a18); + }, a, n & 0xff); + } else { + v = ((a09: rt.isize, a17: rt.u8): rt.isize => { + return rt.isizeShl(a09, a17); + })(a, n & 0xff); + } + } else if (_30 === 28) { + const _222: rt.u8 = rt.u8Rem(form, 3); + if (_222 === 0) { + v = ~a; + } else if (_222 === 1) { + v = one$ref_isize_isize_ops_Not_not_ref_isize((a08: rt.isize): rt.isize => { + return ~a08; + }, a); + } else { + v = ((a07: rt.isize): rt.isize => { + return ~a07; + })(a); + } + } else if (_30 === 29) { + let x11: rt.isize = a; + const _230: rt.u8 = rt.u8Rem(form, 3); + if (_230 === 0) { + x11 = rt.isizeAdd(x11, b); + } else if (_230 === 1) { + two$mut_isize_ref_isize_unit_ops_AddAssign_add_assign_isize_ref_isize((a06: rt.Place, a16: rt.isize): undefined => { + a06.v = rt.isizeAdd(a06.v, a16); + }, rt.place(() => x11, (value6) => x11 = value6), b); + } else { + ((a05: rt.Place, a15: rt.isize): undefined => { + a05.v = rt.isizeAdd(a05.v, a15); + })(rt.place(() => x11, (value5) => x11 = value5), b); + } + v = x11; + } else if (_30 === 30) { + let x12: rt.isize = a; + const _241: rt.u8 = rt.u8Rem(form, 3); + if (_241 === 0) { + x12 = rt.isizeDiv(x12, b); + } else if (_241 === 1) { + two$mut_isize_ref_isize_unit_ops_DivAssign_div_assign_isize_ref_isize((a04: rt.Place, a14: rt.isize): undefined => { + a04.v = rt.isizeDiv(a04.v, a14); + }, rt.place(() => x12, (value4) => x12 = value4), b); + } else { + ((a03: rt.Place, a13: rt.isize): undefined => { + a03.v = rt.isizeDiv(a03.v, a13); + })(rt.place(() => x12, (value3) => x12 = value3), b); + } + v = x12; + } else { + let x13: rt.isize = a; + const _252: rt.u8 = rt.u8Rem(form, 3); + if (_252 === 0) { + x13 = rt.isizeShr(x13, n & 0xffff); + } else if (_252 === 1) { + two$mut_isize_ref_u16_unit_ops_ShrAssign_shr_assign_isize_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { + a02.v = rt.isizeShr(a02.v, a12); + }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + } else { + ((a0: rt.Place, a1: rt.u16): undefined => { + a0.v = rt.isizeShr(a0.v, a1); + })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + } + v = x13; + } + _28(out, v); + } +} + +/** + * Apply operator `kind` to two doubles' bits taken from `data`, rounded to the type, + * in the form its first byte picks. + */ +export function f64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.f64; + let v2!: rt.f64; + const take: (a0: rt.usize) => rt.f64 = (at: rt.usize): rt.f64 => { + const buf: Uint8Array = rt.bytes(8); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _103: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_103 === rt.DONE) { + break; + } + _103[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _103[0])), 0); + } + return rt.f64FromBits(rt.u64FromBeBytes(buf)); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.f64, rt.f64] = [take(1), take(9)]; + const a: rt.f64 = _10[0]; + const b: rt.f64 = _10[1]; + const _18: rt.u8 = rt.u8Rem(kind, 16); + if (_18 === 0) { + const _20: rt.u8 = rt.u8Rem(form, 3); + if (_20 === 0) { + v = a + b; + } else if (_20 === 1) { + v = two$f64_f64_f64_ops_Add_add_f64_f64((a032: rt.f64, a128: rt.f64): rt.f64 => { + return a032 + a128; + }, a, b); + } else { + v = ((a031: rt.f64, a127: rt.f64): rt.f64 => { + return a031 + a127; + })(a, b); + } + } else if (_18 === 1) { + const _23: rt.u8 = rt.u8Rem(form, 3); + if (_23 === 0) { + v = a - b; + } else if (_23 === 1) { + v = two$f64_f64_f64_ops_Sub_sub_f64_f64((a030: rt.f64, a126: rt.f64): rt.f64 => { + return a030 - a126; + }, a, b); + } else { + v = ((a029: rt.f64, a125: rt.f64): rt.f64 => { + return a029 - a125; + })(a, b); + } + } else if (_18 === 2) { + const _26: rt.u8 = rt.u8Rem(form, 3); + if (_26 === 0) { + v = a * b; + } else if (_26 === 1) { + v = two$f64_f64_f64_ops_Mul_mul_f64_f64((a028: rt.f64, a124: rt.f64): rt.f64 => { + return a028 * a124; + }, a, b); + } else { + v = ((a027: rt.f64, a123: rt.f64): rt.f64 => { + return a027 * a123; + })(a, b); + } + } else if (_18 === 3) { + const _29: rt.u8 = rt.u8Rem(form, 3); + if (_29 === 0) { + v = a / b; + } else if (_29 === 1) { + v = two$f64_f64_f64_ops_Div_div_f64_f64((a026: rt.f64, a122: rt.f64): rt.f64 => { + return a026 / a122; + }, a, b); + } else { + v = ((a025: rt.f64, a121: rt.f64): rt.f64 => { + return a025 / a121; + })(a, b); + } + } else if (_18 === 4) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = a % b; + } else if (_32 === 1) { + v = two$f64_f64_f64_ops_Rem_rem_f64_f64((a024: rt.f64, a120: rt.f64): rt.f64 => { + return a024 % a120; + }, a, b); + } else { + v = ((a023: rt.f64, a119: rt.f64): rt.f64 => { + return a023 % a119; + })(a, b); + } + } else if (_18 === 5) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = -a; + } else if (_35 === 1) { + v = one$f64_f64_ops_Neg_neg_f64((a022: rt.f64): rt.f64 => { + return -a022; + }, a); + } else { + v = ((a021: rt.f64): rt.f64 => { + return -a021; + })(a); + } + } else if (_18 === 6) { + let x: rt.f64 = a; + const _40: rt.u8 = rt.u8Rem(form, 3); + if (_40 === 0) { + x = x + b; + } else if (_40 === 1) { + two$mut_f64_f64_unit_ops_AddAssign_add_assign_f64_f64((a020: rt.Place, a118: rt.f64): undefined => { + a020.v = a020.v + a118; + }, rt.place(() => x, (value14) => x = value14), b); + } else { + ((a019: rt.Place, a117: rt.f64): undefined => { + a019.v = a019.v + a117; + })(rt.place(() => x, (value13) => x = value13), b); + } + v = x; + } else if (_18 === 7) { + let x2: rt.f64 = a; + const _48: rt.u8 = rt.u8Rem(form, 3); + if (_48 === 0) { + x2 = x2 - b; + } else if (_48 === 1) { + two$mut_f64_f64_unit_ops_SubAssign_sub_assign_f64_f64((a018: rt.Place, a116: rt.f64): undefined => { + a018.v = a018.v - a116; + }, rt.place(() => x2, (value12) => x2 = value12), b); + } else { + ((a017: rt.Place, a115: rt.f64): undefined => { + a017.v = a017.v - a115; + })(rt.place(() => x2, (value11) => x2 = value11), b); + } + v = x2; + } else if (_18 === 8) { + let x3: rt.f64 = a; + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + x3 = x3 * b; + } else if (_56 === 1) { + two$mut_f64_f64_unit_ops_MulAssign_mul_assign_f64_f64((a016: rt.Place, a114: rt.f64): undefined => { + a016.v = a016.v * a114; + }, rt.place(() => x3, (value10) => x3 = value10), b); + } else { + ((a015: rt.Place, a113: rt.f64): undefined => { + a015.v = a015.v * a113; + })(rt.place(() => x3, (value9) => x3 = value9), b); + } + v = x3; + } else if (_18 === 9) { + let x4: rt.f64 = a; + const _64: rt.u8 = rt.u8Rem(form, 3); + if (_64 === 0) { + x4 = x4 / b; + } else if (_64 === 1) { + two$mut_f64_f64_unit_ops_DivAssign_div_assign_f64_f64((a014: rt.Place, a112: rt.f64): undefined => { + a014.v = a014.v / a112; + }, rt.place(() => x4, (value8) => x4 = value8), b); + } else { + ((a013: rt.Place, a111: rt.f64): undefined => { + a013.v = a013.v / a111; + })(rt.place(() => x4, (value7) => x4 = value7), b); + } + v = x4; + } else if (_18 === 10) { + let x5: rt.f64 = a; + const _72: rt.u8 = rt.u8Rem(form, 3); + if (_72 === 0) { + x5 = x5 % b; + } else if (_72 === 1) { + two$mut_f64_f64_unit_ops_RemAssign_rem_assign_f64_f64((a012: rt.Place, a110: rt.f64): undefined => { + a012.v = a012.v % a110; + }, rt.place(() => x5, (value6) => x5 = value6), b); + } else { + ((a011: rt.Place, a19: rt.f64): undefined => { + a011.v = a011.v % a19; + })(rt.place(() => x5, (value5) => x5 = value5), b); + } + v = x5; + } else if (_18 === 11) { + const _78: rt.u8 = rt.u8Rem(form, 3); + if (_78 === 0) { + v = a + b; + } else if (_78 === 1) { + v = two$ref_f64_ref_f64_f64_ops_Add_add_ref_f64_ref_f64((a010: rt.f64, a18: rt.f64): rt.f64 => { + return a010 + a18; + }, a, b); + } else { + v = ((a09: rt.f64, a17: rt.f64): rt.f64 => { + return a09 + a17; + })(a, b); + } + } else if (_18 === 12) { + const _87: rt.u8 = rt.u8Rem(form, 3); + if (_87 === 0) { + v = a % b; + } else if (_87 === 1) { + v = two$f64_ref_f64_f64_ops_Rem_rem_f64_ref_f64((a08: rt.f64, a16: rt.f64): rt.f64 => { + return a08 % a16; + }, a, b); + } else { + v = ((a07: rt.f64, a15: rt.f64): rt.f64 => { + return a07 % a15; + })(a, b); + } + } else if (_18 === 13) { + const _93: rt.u8 = rt.u8Rem(form, 3); + if (_93 === 0) { + v = -a; + } else if (_93 === 1) { + v = one$ref_f64_f64_ops_Neg_neg_ref_f64((a06: rt.f64): rt.f64 => { + return -a06; + }, a); + } else { + v = ((a05: rt.f64): rt.f64 => { + return -a05; + })(a); + } + } else if (_18 === 14) { + let x6: rt.f64 = a; + const _101: rt.u8 = rt.u8Rem(form, 3); + if (_101 === 0) { + x6 = x6 * b; + } else if (_101 === 1) { + two$mut_f64_ref_f64_unit_ops_MulAssign_mul_assign_f64_ref_f64((a04: rt.Place, a14: rt.f64): undefined => { + a04.v = a04.v * a14; + }, rt.place(() => x6, (value4) => x6 = value4), b); + } else { + ((a03: rt.Place, a13: rt.f64): undefined => { + a03.v = a03.v * a13; + })(rt.place(() => x6, (value3) => x6 = value3), b); + } + v = x6; + } else { + let x7: rt.f64 = a; + const _112: rt.u8 = rt.u8Rem(form, 3); + if (_112 === 0) { + x7 = x7 % b; + } else if (_112 === 1) { + two$mut_f64_ref_f64_unit_ops_RemAssign_rem_assign_f64_ref_f64((a02: rt.Place, a12: rt.f64): undefined => { + a02.v = a02.v % a12; + }, rt.place(() => x7, (value2) => x7 = value2), b); + } else { + ((a0: rt.Place, a1: rt.f64): undefined => { + a0.v = a0.v % a1; + })(rt.place(() => x7, (value) => x7 = value), b); + } + v = x7; + } + if (!Number.isNaN(v)) { + v2 = v; + } else { + v2 = NaN; + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.f64ToBits(v2)))); +} + +/** + * Apply operator `kind` to two doubles' bits taken from `data`, rounded to the type, + * in the form its first byte picks. + */ +export function f32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: rt.f32; + let v2!: rt.f32; + const take: (a0: rt.usize) => rt.f32 = (at: rt.usize): rt.f32 => { + const buf: Uint8Array = rt.bytes(8); + const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + while (true) { + const _103: [rt.usize, rt.Place] | rt.Done = iter.next(); + if (_103 === rt.DONE) { + break; + } + _103[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _103[0])), 0); + } + return Math.fround(rt.f64FromBits(rt.u64FromBeBytes(buf))); + }; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const _10: [rt.f32, rt.f32] = [take(1), take(9)]; + const a: rt.f32 = _10[0]; + const b: rt.f32 = _10[1]; + const _18: rt.u8 = rt.u8Rem(kind, 16); + if (_18 === 0) { + const _20: rt.u8 = rt.u8Rem(form, 3); + if (_20 === 0) { + v = Math.fround(a + b); + } else if (_20 === 1) { + v = two$f32_f32_f32_ops_Add_add_f32_f32((a032: rt.f32, a128: rt.f32): rt.f32 => { + return Math.fround(a032 + a128); + }, a, b); + } else { + v = ((a031: rt.f32, a127: rt.f32): rt.f32 => { + return Math.fround(a031 + a127); + })(a, b); + } + } else if (_18 === 1) { + const _23: rt.u8 = rt.u8Rem(form, 3); + if (_23 === 0) { + v = Math.fround(a - b); + } else if (_23 === 1) { + v = two$f32_f32_f32_ops_Sub_sub_f32_f32((a030: rt.f32, a126: rt.f32): rt.f32 => { + return Math.fround(a030 - a126); + }, a, b); + } else { + v = ((a029: rt.f32, a125: rt.f32): rt.f32 => { + return Math.fround(a029 - a125); + })(a, b); + } + } else if (_18 === 2) { + const _26: rt.u8 = rt.u8Rem(form, 3); + if (_26 === 0) { + v = Math.fround(a * b); + } else if (_26 === 1) { + v = two$f32_f32_f32_ops_Mul_mul_f32_f32((a028: rt.f32, a124: rt.f32): rt.f32 => { + return Math.fround(a028 * a124); + }, a, b); + } else { + v = ((a027: rt.f32, a123: rt.f32): rt.f32 => { + return Math.fround(a027 * a123); + })(a, b); + } + } else if (_18 === 3) { + const _29: rt.u8 = rt.u8Rem(form, 3); + if (_29 === 0) { + v = Math.fround(a / b); + } else if (_29 === 1) { + v = two$f32_f32_f32_ops_Div_div_f32_f32((a026: rt.f32, a122: rt.f32): rt.f32 => { + return Math.fround(a026 / a122); + }, a, b); + } else { + v = ((a025: rt.f32, a121: rt.f32): rt.f32 => { + return Math.fround(a025 / a121); + })(a, b); + } + } else if (_18 === 4) { + const _32: rt.u8 = rt.u8Rem(form, 3); + if (_32 === 0) { + v = a % b; + } else if (_32 === 1) { + v = two$f32_f32_f32_ops_Rem_rem_f32_f32((a024: rt.f32, a120: rt.f32): rt.f32 => { + return a024 % a120; + }, a, b); + } else { + v = ((a023: rt.f32, a119: rt.f32): rt.f32 => { + return a023 % a119; + })(a, b); + } + } else if (_18 === 5) { + const _35: rt.u8 = rt.u8Rem(form, 3); + if (_35 === 0) { + v = -a; + } else if (_35 === 1) { + v = one$f32_f32_ops_Neg_neg_f32((a022: rt.f32): rt.f32 => { + return -a022; + }, a); + } else { + v = ((a021: rt.f32): rt.f32 => { + return -a021; + })(a); + } + } else if (_18 === 6) { + let x: rt.f32 = a; + const _40: rt.u8 = rt.u8Rem(form, 3); + if (_40 === 0) { + x = Math.fround(x + b); + } else if (_40 === 1) { + two$mut_f32_f32_unit_ops_AddAssign_add_assign_f32_f32((a020: rt.Place, a118: rt.f32): undefined => { + a020.v = Math.fround(a020.v + a118); + }, rt.place(() => x, (value14) => x = value14), b); + } else { + ((a019: rt.Place, a117: rt.f32): undefined => { + a019.v = Math.fround(a019.v + a117); + })(rt.place(() => x, (value13) => x = value13), b); + } + v = x; + } else if (_18 === 7) { + let x2: rt.f32 = a; + const _48: rt.u8 = rt.u8Rem(form, 3); + if (_48 === 0) { + x2 = Math.fround(x2 - b); + } else if (_48 === 1) { + two$mut_f32_f32_unit_ops_SubAssign_sub_assign_f32_f32((a018: rt.Place, a116: rt.f32): undefined => { + a018.v = Math.fround(a018.v - a116); + }, rt.place(() => x2, (value12) => x2 = value12), b); + } else { + ((a017: rt.Place, a115: rt.f32): undefined => { + a017.v = Math.fround(a017.v - a115); + })(rt.place(() => x2, (value11) => x2 = value11), b); + } + v = x2; + } else if (_18 === 8) { + let x3: rt.f32 = a; + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + x3 = Math.fround(x3 * b); + } else if (_56 === 1) { + two$mut_f32_f32_unit_ops_MulAssign_mul_assign_f32_f32((a016: rt.Place, a114: rt.f32): undefined => { + a016.v = Math.fround(a016.v * a114); + }, rt.place(() => x3, (value10) => x3 = value10), b); + } else { + ((a015: rt.Place, a113: rt.f32): undefined => { + a015.v = Math.fround(a015.v * a113); + })(rt.place(() => x3, (value9) => x3 = value9), b); + } + v = x3; + } else if (_18 === 9) { + let x4: rt.f32 = a; + const _64: rt.u8 = rt.u8Rem(form, 3); + if (_64 === 0) { + x4 = Math.fround(x4 / b); + } else if (_64 === 1) { + two$mut_f32_f32_unit_ops_DivAssign_div_assign_f32_f32((a014: rt.Place, a112: rt.f32): undefined => { + a014.v = Math.fround(a014.v / a112); + }, rt.place(() => x4, (value8) => x4 = value8), b); + } else { + ((a013: rt.Place, a111: rt.f32): undefined => { + a013.v = Math.fround(a013.v / a111); + })(rt.place(() => x4, (value7) => x4 = value7), b); + } + v = x4; + } else if (_18 === 10) { + let x5: rt.f32 = a; + const _72: rt.u8 = rt.u8Rem(form, 3); + if (_72 === 0) { + x5 = x5 % b; + } else if (_72 === 1) { + two$mut_f32_f32_unit_ops_RemAssign_rem_assign_f32_f32((a012: rt.Place, a110: rt.f32): undefined => { + a012.v = a012.v % a110; + }, rt.place(() => x5, (value6) => x5 = value6), b); + } else { + ((a011: rt.Place, a19: rt.f32): undefined => { + a011.v = a011.v % a19; + })(rt.place(() => x5, (value5) => x5 = value5), b); + } + v = x5; + } else if (_18 === 11) { + const _78: rt.u8 = rt.u8Rem(form, 3); + if (_78 === 0) { + v = Math.fround(a + b); + } else if (_78 === 1) { + v = two$ref_f32_ref_f32_f32_ops_Add_add_ref_f32_ref_f32((a010: rt.f32, a18: rt.f32): rt.f32 => { + return Math.fround(a010 + a18); + }, a, b); + } else { + v = ((a09: rt.f32, a17: rt.f32): rt.f32 => { + return Math.fround(a09 + a17); + })(a, b); + } + } else if (_18 === 12) { + const _87: rt.u8 = rt.u8Rem(form, 3); + if (_87 === 0) { + v = a % b; + } else if (_87 === 1) { + v = two$f32_ref_f32_f32_ops_Rem_rem_f32_ref_f32((a08: rt.f32, a16: rt.f32): rt.f32 => { + return a08 % a16; + }, a, b); + } else { + v = ((a07: rt.f32, a15: rt.f32): rt.f32 => { + return a07 % a15; + })(a, b); + } + } else if (_18 === 13) { + const _93: rt.u8 = rt.u8Rem(form, 3); + if (_93 === 0) { + v = -a; + } else if (_93 === 1) { + v = one$ref_f32_f32_ops_Neg_neg_ref_f32((a06: rt.f32): rt.f32 => { + return -a06; + }, a); + } else { + v = ((a05: rt.f32): rt.f32 => { + return -a05; + })(a); + } + } else if (_18 === 14) { + let x6: rt.f32 = a; + const _101: rt.u8 = rt.u8Rem(form, 3); + if (_101 === 0) { + x6 = Math.fround(x6 * b); + } else if (_101 === 1) { + two$mut_f32_ref_f32_unit_ops_MulAssign_mul_assign_f32_ref_f32((a04: rt.Place, a14: rt.f32): undefined => { + a04.v = Math.fround(a04.v * a14); + }, rt.place(() => x6, (value4) => x6 = value4), b); + } else { + ((a03: rt.Place, a13: rt.f32): undefined => { + a03.v = Math.fround(a03.v * a13); + })(rt.place(() => x6, (value3) => x6 = value3), b); + } + v = x6; + } else { + let x7: rt.f32 = a; + const _112: rt.u8 = rt.u8Rem(form, 3); + if (_112 === 0) { + x7 = x7 % b; + } else if (_112 === 1) { + two$mut_f32_ref_f32_unit_ops_RemAssign_rem_assign_f32_ref_f32((a02: rt.Place, a12: rt.f32): undefined => { + a02.v = a02.v % a12; + }, rt.place(() => x7, (value2) => x7 = value2), b); + } else { + ((a0: rt.Place, a1: rt.f32): undefined => { + a0.v = a0.v % a1; + })(rt.place(() => x7, (value) => x7 = value), b); + } + v = x7; + } + if (!Number.isNaN(v)) { + v2 = v; + } else { + v2 = NaN; + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(v2)))); +} + +/** + * Apply operator `kind` to the two bools the low bits of `data`'s second byte pick, in the + * form its first byte picks. + */ +export function bools(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let v!: boolean; + const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const bits: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); + const _12: [boolean, boolean] = [(bits & 1) === 1, (bits & 2) === 2]; + const a: boolean = _12[0]; + const b: boolean = _12[1]; + const _18: rt.u8 = rt.u8Rem(kind, 10); + if (_18 === 0) { + const _20: rt.u8 = rt.u8Rem(form, 3); + if (_20 === 0) { + v = a && b; + } else if (_20 === 1) { + v = two$bool_bool_bool_ops_BitAnd_bitand_bool_bool((a020: boolean, a116: boolean): boolean => { + return a020 && a116; + }, a, b); + } else { + v = ((a019: boolean, a115: boolean): boolean => { + return a019 && a115; + })(a, b); + } + } else if (_18 === 1) { + const _23: rt.u8 = rt.u8Rem(form, 3); + if (_23 === 0) { + v = a || b; + } else if (_23 === 1) { + v = two$bool_bool_bool_ops_BitOr_bitor_bool_bool((a018: boolean, a114: boolean): boolean => { + return a018 || a114; + }, a, b); + } else { + v = ((a017: boolean, a113: boolean): boolean => { + return a017 || a113; + })(a, b); + } + } else if (_18 === 2) { + const _26: rt.u8 = rt.u8Rem(form, 3); + if (_26 === 0) { + v = a !== b; + } else if (_26 === 1) { + v = two$bool_bool_bool_ops_BitXor_bitxor_bool_bool((a016: boolean, a112: boolean): boolean => { + return a016 !== a112; + }, a, b); + } else { + v = ((a015: boolean, a111: boolean): boolean => { + return a015 !== a111; + })(a, b); + } + } else if (_18 === 3) { + const _29: rt.u8 = rt.u8Rem(form, 3); + if (_29 === 0) { + v = !a; + } else if (_29 === 1) { + v = one$bool_bool_ops_Not_not_bool((a014: boolean): boolean => { + return !a014; + }, a); + } else { + v = ((a013: boolean): boolean => { + return !a013; + })(a); + } + } else if (_18 === 4) { + let x: boolean = a; + const _34: rt.u8 = rt.u8Rem(form, 3); + if (_34 === 0) { + x = x && b; + } else if (_34 === 1) { + two$mut_bool_bool_unit_ops_BitAndAssign_bitand_assign_bool_bool((a012: rt.Place, a110: boolean): undefined => { + a012.v = a012.v && a110; + }, rt.place(() => x, (value8) => x = value8), b); + } else { + ((a011: rt.Place, a19: boolean): undefined => { + a011.v = a011.v && a19; + })(rt.place(() => x, (value7) => x = value7), b); + } + v = x; + } else if (_18 === 5) { + let x2: boolean = a; + const _42: rt.u8 = rt.u8Rem(form, 3); + if (_42 === 0) { + x2 = x2 || b; + } else if (_42 === 1) { + two$mut_bool_bool_unit_ops_BitOrAssign_bitor_assign_bool_bool((a010: rt.Place, a18: boolean): undefined => { + a010.v = a010.v || a18; + }, rt.place(() => x2, (value6) => x2 = value6), b); + } else { + ((a09: rt.Place, a17: boolean): undefined => { + a09.v = a09.v || a17; + })(rt.place(() => x2, (value5) => x2 = value5), b); + } + v = x2; + } else if (_18 === 6) { + let x3: boolean = a; + const _50: rt.u8 = rt.u8Rem(form, 3); + if (_50 === 0) { + x3 = x3 !== b; + } else if (_50 === 1) { + two$mut_bool_bool_unit_ops_BitXorAssign_bitxor_assign_bool_bool((a08: rt.Place, a16: boolean): undefined => { + a08.v = a08.v !== a16; + }, rt.place(() => x3, (value4) => x3 = value4), b); + } else { + ((a07: rt.Place, a15: boolean): undefined => { + a07.v = a07.v !== a15; + })(rt.place(() => x3, (value3) => x3 = value3), b); + } + v = x3; + } else if (_18 === 7) { + const _56: rt.u8 = rt.u8Rem(form, 3); + if (_56 === 0) { + v = a && b; + } else if (_56 === 1) { + v = two$ref_bool_ref_bool_bool_ops_BitAnd_bitand_ref_bool_ref_bool((a06: boolean, a14: boolean): boolean => { + return a06 && a14; + }, a, b); + } else { + v = ((a05: boolean, a13: boolean): boolean => { + return a05 && a13; + })(a, b); + } + } else if (_18 === 8) { + const _65: rt.u8 = rt.u8Rem(form, 3); + if (_65 === 0) { + v = !a; + } else if (_65 === 1) { + v = one$ref_bool_bool_ops_Not_not_ref_bool((a04: boolean): boolean => { + return !a04; + }, a); + } else { + v = ((a03: boolean): boolean => { + return !a03; + })(a); + } + } else { + let x4: boolean = a; + const _73: rt.u8 = rt.u8Rem(form, 3); + if (_73 === 0) { + x4 = x4 || b; + } else if (_73 === 1) { + two$mut_bool_ref_bool_unit_ops_BitOrAssign_bitor_assign_bool_ref_bool((a02: rt.Place, a12: boolean): undefined => { + a02.v = a02.v || a12; + }, rt.place(() => x4, (value2) => x4 = value2), b); + } else { + ((a0: rt.Place, a1: boolean): undefined => { + a0.v = a0.v || a1; + })(rt.place(() => x4, (value) => x4 = value), b); + } + v = x4; + } + rt.byteVecPush(out, v ? 1 : 0); +} + +//# sourceMappingURL=operators.ts.map diff --git a/ts/fixtures/lang/operators/src/lib.rs b/ts/fixtures/lang/operators/src/lib.rs new file mode 100644 index 000000000..b971a3d1f --- /dev/null +++ b/ts/fixtures/lang/operators/src/lib.rs @@ -0,0 +1,35 @@ +//! A part of the language the driver translates, exercised against native Rust: what +//! each of its modules says. + +#[path = "../../harness.rs"] +pub mod harness; +mod operators; +#[cfg(target_arch = "wasm32")] +#[path = "../../../wasm.rs"] +mod wasm; +#[cfg(target_arch = "wasm32")] +use harness::run as entry; + +use harness::Case; + +/// Each case's name and what it runs. The first two bytes, big-endian, pick one modulo +/// their count, so a case added at the end moves no other. +fn cases() -> Vec<(&'static str, Case)> { + vec![ + ("operators::u8s", operators::u8s), + ("operators::u16s", operators::u16s), + ("operators::u32s", operators::u32s), + ("operators::u64s", operators::u64s), + ("operators::u128s", operators::u128s), + ("operators::usizes", operators::usizes), + ("operators::i8s", operators::i8s), + ("operators::i16s", operators::i16s), + ("operators::i32s", operators::i32s), + ("operators::i64s", operators::i64s), + ("operators::i128s", operators::i128s), + ("operators::isizes", operators::isizes), + ("operators::f64s", operators::f64s), + ("operators::f32s", operators::f32s), + ("operators::bools", operators::bools), + ] +} diff --git a/ts/fixtures/lang/operators/src/operators.rs b/ts/fixtures/lang/operators/src/operators.rs new file mode 100644 index 000000000..a5b56fae0 --- /dev/null +++ b/ts/fixtures/lang/operators/src/operators.rs @@ -0,0 +1,206 @@ +//! std's operator traits' methods called by path on primitives, which the operators lower +//! to MIR's own operations: of every integer width, `f64`, `f32`, and `bool`, by value and +//! by reference, and their assign forms. Each is written as a call, passed as a function +//! value that a generic body calls, and coerced to a function pointer, and must overflow, +//! panic, and round where its operator does. One operation per case, so a panic hides +//! nothing. + +use std::ops::{ + Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Div, DivAssign, Mul, MulAssign, + Neg, Not, Rem, RemAssign, Shl, ShlAssign, Shr, ShrAssign, Sub, SubAssign, +}; + +/// `f(a)`, as a generic body calls a function value. +fn one(f: impl FnOnce(A) -> R, a: A) -> R { + f(a) +} + +/// `f(a, b)`, as a generic body calls a function value. +fn two(f: impl FnOnce(A, B) -> R, a: A, b: B) -> R { + f(a, b) +} + +/// `f` applied to the arguments as `form` picks: written as a call, as a function value, or +/// through a function pointer. +macro_rules! by { + ($form:expr, $f:expr, $a:expr) => { + match $form % 3 { + 0 => $f($a), + 1 => one($f, $a), + _ => { + let f: fn(_) -> _ = $f; + f($a) + } + } + }; + ($form:expr, $f:expr, $a:expr, $b:expr) => { + match $form % 3 { + 0 => $f($a, $b), + 1 => two($f, $a, $b), + _ => { + let f: fn(_, _) -> _ = $f; + f($a, $b) + } + } + }; +} + +/// `x` after the assign form `f` applies to it and `b`, as `form` picks. +macro_rules! assigned { + ($form:expr, $f:expr, $x:expr, $b:expr) => {{ + let mut x = $x; + by!($form, $f, &mut x, $b); + x + }}; +} + +/// `Neg` of a signed type, by value and by reference, which an unsigned one lacks. +macro_rules! neg { + (signed, $t:ty, $form:expr, $a:expr) => { + Some(match $form / 3 % 2 { + 0 => by!($form, <$t as Neg>::neg, $a), + _ => by!($form, <&$t as Neg>::neg, &$a), + }) + }; + (unsigned, $t:ty, $form:expr, $a:expr) => { + None::<$t> + }; +} + +macro_rules! ints { + ($name:ident, $t:ty, $wide:ty, $sign:ident) => { + /// Apply operator `kind` to operands taken from `data`, in the form its first byte + /// picks: two operands, then a shift amount, which may pass the width many times over. + pub fn $name(kind: u8, data: &[u8], out: &mut Vec) { + const N: usize = core::mem::size_of::<$t>(); + let take = |at: usize| { + let mut buf = [0u8; N]; + for (i, b) in buf.iter_mut().enumerate() { + *b = data.get(at + i).copied().unwrap_or(0); + } + <$t>::from_be_bytes(buf) + }; + let form = data.first().copied().unwrap_or(0); + let (a, b) = (take(1), take(1 + N)); + let byte = |i: usize| data.get(1 + 2 * N + i).copied().unwrap_or(0); + let n = u32::from_be_bytes([byte(1), 0, 0, byte(0)]); + let put = |out: &mut Vec, v: $t| out.extend_from_slice(&(v as $wide).to_be_bytes()); + let v = match kind % 32 { + 0 => by!(form, <$t as Add>::add, a, b), + 1 => by!(form, <$t as Sub>::sub, a, b), + 2 => by!(form, <$t as Mul>::mul, a, b), + 3 => by!(form, <$t as Div>::div, a, b), + 4 => by!(form, <$t as Rem>::rem, a, b), + 5 => by!(form, <$t as BitAnd>::bitand, a, b), + 6 => by!(form, <$t as BitOr>::bitor, a, b), + 7 => by!(form, <$t as BitXor>::bitxor, a, b), + 8 => by!(form, <$t as Shl>::shl, a, n), + 9 => by!(form, <$t as Shr>::shr, a, n), + // Amounts of other types: a negative one, and one past 32 bits. + 10 => by!(form, <$t as Shl>::shl, a, n as i16), + 11 => by!(form, <$t as Shr>::shr, a, u128::from(n) << (n & 64)), + 12 => by!(form, <$t as Not>::not, a), + 13 => match neg!($sign, $t, form, a) { + Some(v) => v, + None => return, + }, + 14 => assigned!(form, <$t as AddAssign>::add_assign, a, b), + 15 => assigned!(form, <$t as SubAssign>::sub_assign, a, b), + 16 => assigned!(form, <$t as MulAssign>::mul_assign, a, b), + 17 => assigned!(form, <$t as DivAssign>::div_assign, a, b), + 18 => assigned!(form, <$t as RemAssign>::rem_assign, a, b), + 19 => assigned!(form, <$t as BitAndAssign>::bitand_assign, a, b), + 20 => assigned!(form, <$t as BitOrAssign>::bitor_assign, a, b), + 21 => assigned!(form, <$t as BitXorAssign>::bitxor_assign, a, b), + 22 => assigned!(form, <$t as ShlAssign>::shl_assign, a, n), + 23 => assigned!(form, <$t as ShrAssign>::shr_assign, a, i64::from(n as i16)), + // By reference, on either side. + 24 => by!(form, <$t as Add<&$t>>::add, a, &b), + 25 => by!(form, <&$t as Sub<$t>>::sub, &a, b), + 26 => by!(form, <&$t as Mul<&$t>>::mul, &a, &b), + 27 => by!(form, <&$t as Shl<&u8>>::shl, &a, &(n as u8)), + 28 => by!(form, <&$t as Not>::not, &a), + 29 => assigned!(form, <$t as AddAssign<&$t>>::add_assign, a, &b), + 30 => assigned!(form, <$t as DivAssign<&$t>>::div_assign, a, &b), + _ => assigned!(form, <$t as ShrAssign<&u16>>::shr_assign, a, &(n as u16)), + }; + put(out, v); + } + }; +} + +ints!(u8s, u8, u128, unsigned); +ints!(u16s, u16, u128, unsigned); +ints!(u32s, u32, u128, unsigned); +ints!(u64s, u64, u128, unsigned); +ints!(u128s, u128, u128, unsigned); +ints!(usizes, usize, u128, unsigned); +ints!(i8s, i8, i128, signed); +ints!(i16s, i16, i128, signed); +ints!(i32s, i32, i128, signed); +ints!(i64s, i64, i128, signed); +ints!(i128s, i128, i128, signed); +ints!(isizes, isize, i128, signed); + +macro_rules! floats { + ($name:ident, $t:ty) => { + /// Apply operator `kind` to two doubles' bits taken from `data`, rounded to the type, + /// in the form its first byte picks. + pub fn $name(kind: u8, data: &[u8], out: &mut Vec) { + let take = |at: usize| { + let mut buf = [0u8; 8]; + for (i, b) in buf.iter_mut().enumerate() { + *b = data.get(at + i).copied().unwrap_or(0); + } + f64::from_bits(u64::from_be_bytes(buf)) as $t + }; + let form = data.first().copied().unwrap_or(0); + let (a, b) = (take(1), take(9)); + let v = match kind % 16 { + 0 => by!(form, <$t as Add>::add, a, b), + 1 => by!(form, <$t as Sub>::sub, a, b), + 2 => by!(form, <$t as Mul>::mul, a, b), + 3 => by!(form, <$t as Div>::div, a, b), + 4 => by!(form, <$t as Rem>::rem, a, b), + 5 => by!(form, <$t as Neg>::neg, a), + 6 => assigned!(form, <$t as AddAssign>::add_assign, a, b), + 7 => assigned!(form, <$t as SubAssign>::sub_assign, a, b), + 8 => assigned!(form, <$t as MulAssign>::mul_assign, a, b), + 9 => assigned!(form, <$t as DivAssign>::div_assign, a, b), + 10 => assigned!(form, <$t as RemAssign>::rem_assign, a, b), + 11 => by!(form, <&$t as Add<&$t>>::add, &a, &b), + 12 => by!(form, <$t as Rem<&$t>>::rem, a, &b), + 13 => by!(form, <&$t as Neg>::neg, &a), + 14 => assigned!(form, <$t as MulAssign<&$t>>::mul_assign, a, &b), + _ => assigned!(form, <$t as RemAssign<&$t>>::rem_assign, a, &b), + }; + // Any NaN as the type's own, whose payload no operator here keeps. + let v = if v.is_nan() { <$t>::NAN } else { v }; + out.extend_from_slice(&v.to_bits().to_be_bytes()); + } + }; +} + +floats!(f64s, f64); +floats!(f32s, f32); + +/// Apply operator `kind` to the two bools the low bits of `data`'s second byte pick, in the +/// form its first byte picks. +pub fn bools(kind: u8, data: &[u8], out: &mut Vec) { + let form = data.first().copied().unwrap_or(0); + let bits = data.get(1).copied().unwrap_or(0); + let (a, b) = (bits & 1 == 1, bits & 2 == 2); + let v = match kind % 10 { + 0 => by!(form, ::bitand, a, b), + 1 => by!(form, ::bitor, a, b), + 2 => by!(form, ::bitxor, a, b), + 3 => by!(form, ::not, a), + 4 => assigned!(form, ::bitand_assign, a, b), + 5 => assigned!(form, ::bitor_assign, a, b), + 6 => assigned!(form, ::bitxor_assign, a, b), + 7 => by!(form, <&bool as BitAnd<&bool>>::bitand, &a, &b), + 8 => by!(form, <&bool as Not>::not, &a), + _ => assigned!(form, >::bitor_assign, a, &b), + }; + out.push(v as u8); +} diff --git a/ts/fixtures/lang/operators/ts.toml b/ts/fixtures/lang/operators/ts.toml new file mode 100644 index 000000000..98b037f47 --- /dev/null +++ b/ts/fixtures/lang/operators/ts.toml @@ -0,0 +1,2 @@ +package = "lang-operators-fixture" +roots = ["harness::run", "harness::op"] diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 526dc8a48..5aa207f59 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1567,7 +1567,7 @@ fn mapping<'tcx>( ("Not", "not") if let Some((_, int)) = overflowing(tcx, targ(gargs, 0).peel_refs()) => { num::unary(b, rustc_middle::mir::UnOp::Not, args.pop()?, int, span) } - // Operators on references to primitives. + // Operators on primitives, called by path, and on references to them. (_, _) if let Some(op) = operator(&owner) && primitive(targ(gargs, 0).peel_refs()) => @@ -1584,6 +1584,13 @@ fn mapping<'tcx>( span, ) } + ("Neg", "neg") | ("Not", "not") if primitive(targ(gargs, 0).peel_refs()) => { + let op = match name.as_str() { + "neg" => rustc_middle::mir::UnOp::Neg, + _ => rustc_middle::mir::UnOp::Not, + }; + num::unary(b, op, args.pop()?, targ(gargs, 0), span) + } // Every value of a type holding nothing is equal, and no `!` is ever compared. ("PartialEq", "eq" | "ne") if nothing(tcx, unwrapped(tcx, targ(gargs, 0))) || unwrapped(tcx, targ(gargs, 0)).is_never() => @@ -3260,7 +3267,7 @@ fn compared<'tcx>(tcx: TyCtxt<'tcx>, mut ty: Ty<'tcx>) -> Option> { primitive(ty).then_some(ty) } -fn primitive(ty: Ty<'_>) -> bool { +pub fn primitive(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Char) || super::float::is(ty) } diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 404adc8d2..e5ffbfd20 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -804,11 +804,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; done(Expr::rt(f, values), true) } - // A `Wrapping` or a `Saturating` is its integer, so what the `&mut` borrows gets the - // wrapped or saturated result. + // What the `&mut` borrows gets the result: a primitive's operator's, as `+=` on one + // computes, or a `Wrapping`'s or a `Saturating`'s, which is its integer, wrapped or + // saturated. (_, _) if let Some(op) = owner.strip_suffix("Assign").and_then(library::operator) - && let Some((overflow, int)) = targ(0).and_then(|t| library::overflowing(tcx, t)) => + && let Some(ty) = targ(0) + && (library::primitive(ty) || library::overflowing(tcx, ty).is_some()) => { let place = self.borrowed_place(&args[0].node, span, out)?; let by = self.operand(&args[1].node, span, out); @@ -820,7 +822,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { expr: by, value: self.const_int(&args[1].node), }; - let value = crate::lower::num::overflowing(self.b, overflow, op, l, r, int, span); + let value = match library::overflowing(tcx, ty) { + Some((overflow, int)) => crate::lower::num::overflowing(self.b, overflow, op, l, r, int, span), + None => crate::lower::num::binary(self.b, op, l, r, ty, targ(1)?, span), + }; self.set_borrowed(&place, value, span, out); done(Expr::undefined(), false) } diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index 44c890172..c74f9a565 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -420,6 +420,7 @@ mod lang { methods, nested, objects, + operators, orders, pointers, refs,