@fluffylabs/anan-as 1.2.0-c2b7f5a → 1.2.0-d27ef10

package/dist/build/js/assembly/instructions/math.js

@@ -1,225 +1,225 @@
 import { portable } from "../portable";
-import { ok } from "./outcome";
-import { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst, mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned } from "./utils";
 // ADD_IMM_32
 export const add_imm_32 = (r, args, registers) => {
-    const a = registers[reg(args.a)];
-    const c = u32SignExtend(args.c);
-    registers[reg(args.b)] = u32SignExtend(u32(portable.u64_add(a, c)));
-    return ok(r);
+    const a = registers[Inst.reg(args.a)];
+    const c = Inst.u32SignExtend(args.c);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(portable.u64_add(a, c)));
+    return OutcomeData.ok(r);
 };
 // MUL_IMM_32
 export const mul_imm_32 = (r, args, registers) => {
-    registers[reg(args.b)] = u32SignExtend(u32(portable.u64_mul(registers[reg(args.a)], u64(args.c))));
-    return ok(r);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(portable.u64_mul(registers[Inst.reg(args.a)], u64(args.c))));
+    return OutcomeData.ok(r);
 };
 // NEG_ADD_IMM_32
 export const neg_add_imm_32 = (r, args, registers) => {
-    const sum = portable.u64_sub(u64(args.c) | u64(4294967296), registers[reg(args.a)]);
-    registers[reg(args.b)] = u32SignExtend(u32(sum));
-    return ok(r);
+    const sum = portable.u64_sub(u64(args.c) | u64(4294967296), registers[Inst.reg(args.a)]);
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(sum));
+    return OutcomeData.ok(r);
 };
 // ADD_IMM
 export const add_imm = (r, args, registers) => {
-    const sum = portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c));
-    registers[reg(args.b)] = sum;
-    return ok(r);
+    const sum = portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = sum;
+    return OutcomeData.ok(r);
 };
 // MUL_IMM
 export const mul_imm = (r, args, registers) => {
-    registers[reg(args.b)] = portable.u64_mul(registers[reg(args.a)], u32SignExtend(args.c));
-    return ok(r);
+    registers[Inst.reg(args.b)] = portable.u64_mul(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c));
+    return OutcomeData.ok(r);
 };
 // NEG_ADD_IMM
 export const neg_add_imm = (r, args, registers) => {
-    const sum = portable.u64_sub(u32SignExtend(args.c), registers[reg(args.a)]);
-    registers[reg(args.b)] = sum;
-    return ok(r);
+    const sum = portable.u64_sub(Inst.u32SignExtend(args.c), registers[Inst.reg(args.a)]);
+    registers[Inst.reg(args.b)] = sum;
+    return OutcomeData.ok(r);
 };
 // ADD_32
 export const add_32 = (r, args, registers) => {
-    const a = u32(registers[reg(args.a)]);
-    const b = u32(registers[reg(args.b)]);
-    registers[reg(args.c)] = u32SignExtend(a + b);
-    return ok(r);
+    const a = u32(registers[Inst.reg(args.a)]);
+    const b = u32(registers[Inst.reg(args.b)]);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(a + b);
+    return OutcomeData.ok(r);
 };
 // SUB_32
 export const sub_32 = (r, args, registers) => {
-    const a = registers[reg(args.b)];
-    const b = u64(4294967296 - u32(registers[reg(args.a)]));
-    registers[reg(args.c)] = u32SignExtend(u32(portable.u64_add(a, b)));
-    return ok(r);
+    const a = registers[Inst.reg(args.b)];
+    const b = u64(4294967296 - u32(registers[Inst.reg(args.a)]));
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(u32(portable.u64_add(a, b)));
+    return OutcomeData.ok(r);
 };
 // MUL_32
 export const mul_32 = (r, args, registers) => {
-    registers[reg(args.c)] = u32SignExtend(u32(portable.u64_mul(registers[reg(args.a)], registers[reg(args.b)])));
-    return ok(r);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(u32(portable.u64_mul(registers[Inst.reg(args.a)], registers[Inst.reg(args.b)])));
+    return OutcomeData.ok(r);
 };
 // DIV_U_32
 export const div_u_32 = (r, args, registers) => {
-    const a = u32(registers[reg(args.a)]);
+    const a = u32(registers[Inst.reg(args.a)]);
     if (a === 0) {
-        registers[reg(args.c)] = u64.MAX_VALUE;
+        registers[Inst.reg(args.c)] = u64.MAX_VALUE;
     }
     else {
-        const b = u32(registers[reg(args.b)]);
-        registers[reg(args.c)] = u32SignExtend(b / a);
+        const b = u32(registers[Inst.reg(args.b)]);
+        registers[Inst.reg(args.c)] = Inst.u32SignExtend(b / a);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // DIV_S_32
 export const div_s_32 = (r, args, registers) => {
-    const b = i64(u32SignExtend(u32(registers[reg(args.b)])));
-    const a = i64(u32SignExtend(u32(registers[reg(args.a)])));
+    const b = i64(Inst.u32SignExtend(u32(registers[Inst.reg(args.b)])));
+    const a = i64(Inst.u32SignExtend(u32(registers[Inst.reg(args.a)])));
     if (a === i64(0)) {
-        registers[reg(args.c)] = u64.MAX_VALUE;
+        registers[Inst.reg(args.c)] = u64.MAX_VALUE;
     }
     else if (a === i64(-1) && b === i64(i32.MIN_VALUE)) {
-        registers[reg(args.c)] = u64(b);
+        registers[Inst.reg(args.c)] = u64(b);
     }
     else {
-        registers[reg(args.c)] = u64(b / a);
+        registers[Inst.reg(args.c)] = u64(b / a);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // REM_U_32
 export const rem_u_32 = (r, args, registers) => {
-    const a = u32(registers[reg(args.a)]);
-    const b = u32(registers[reg(args.b)]);
+    const a = u32(registers[Inst.reg(args.a)]);
+    const b = u32(registers[Inst.reg(args.b)]);
     if (a === 0) {
-        registers[reg(args.c)] = u32SignExtend(b);
+        registers[Inst.reg(args.c)] = Inst.u32SignExtend(b);
     }
     else {
-        registers[reg(args.c)] = u32SignExtend(b % a);
+        registers[Inst.reg(args.c)] = Inst.u32SignExtend(b % a);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // REM_S_32
 export const rem_s_32 = (r, args, registers) => {
-    const b = i32(registers[reg(args.b)]);
-    const a = i32(registers[reg(args.a)]);
+    const b = i32(registers[Inst.reg(args.b)]);
+    const a = i32(registers[Inst.reg(args.a)]);
     if (a === 0) {
-        registers[reg(args.c)] = u64(i64(b));
+        registers[Inst.reg(args.c)] = u64(i64(b));
     }
     else if (a === -1 && b === i32.MIN_VALUE) {
-        registers[reg(args.c)] = u64(0);
+        registers[Inst.reg(args.c)] = u64(0);
     }
     else {
-        registers[reg(args.c)] = u64(i64(b) % i64(a));
+        registers[Inst.reg(args.c)] = u64(i64(b) % i64(a));
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // ADD_64
 export const add_64 = (r, args, registers) => {
-    const a = registers[reg(args.a)];
-    const b = registers[reg(args.b)];
-    registers[reg(args.c)] = portable.u64_add(a, b);
-    return ok(r);
+    const a = registers[Inst.reg(args.a)];
+    const b = registers[Inst.reg(args.b)];
+    registers[Inst.reg(args.c)] = portable.u64_add(a, b);
+    return OutcomeData.ok(r);
 };
 // SUB
 export const sub = (r, args, registers) => {
-    const a = registers[reg(args.a)];
-    const b = registers[reg(args.b)];
-    registers[reg(args.c)] = portable.u64_sub(b, a);
-    return ok(r);
+    const a = registers[Inst.reg(args.a)];
+    const b = registers[Inst.reg(args.b)];
+    registers[Inst.reg(args.c)] = portable.u64_sub(b, a);
+    return OutcomeData.ok(r);
 };
 // MUL
 export const mul = (r, args, registers) => {
-    const a = registers[reg(args.a)];
-    const b = registers[reg(args.b)];
-    registers[reg(args.c)] = portable.u64_mul(a, b);
-    return ok(r);
+    const a = registers[Inst.reg(args.a)];
+    const b = registers[Inst.reg(args.b)];
+    registers[Inst.reg(args.c)] = portable.u64_mul(a, b);
+    return OutcomeData.ok(r);
 };
 // DIV_U
 export const div_u = (r, args, registers) => {
-    if (registers[reg(args.a)] === u64(0)) {
-        registers[reg(args.c)] = u64.MAX_VALUE;
+    if (registers[Inst.reg(args.a)] === u64(0)) {
+        registers[Inst.reg(args.c)] = u64.MAX_VALUE;
     }
     else {
-        registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];
+        registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] / registers[Inst.reg(args.a)];
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // DIV_S
 export const div_s = (r, args, registers) => {
-    const b = i64(registers[reg(args.b)]);
-    const a = i64(registers[reg(args.a)]);
+    const b = i64(registers[Inst.reg(args.b)]);
+    const a = i64(registers[Inst.reg(args.a)]);
     if (a === i64(0)) {
-        registers[reg(args.c)] = u64.MAX_VALUE;
+        registers[Inst.reg(args.c)] = u64.MAX_VALUE;
     }
     else if (a === i64(-1) && b === i64.MIN_VALUE) {
-        registers[reg(args.c)] = u64(b);
+        registers[Inst.reg(args.c)] = u64(b);
     }
     else {
-        registers[reg(args.c)] = u64(b / a);
+        registers[Inst.reg(args.c)] = u64(b / a);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // REM_U
 export const rem_u = (r, args, registers) => {
-    if (registers[reg(args.a)] === u64(0)) {
-        registers[reg(args.c)] = registers[reg(args.b)];
+    if (registers[Inst.reg(args.a)] === u64(0)) {
+        registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)];
     }
     else {
-        registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];
+        registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] % registers[Inst.reg(args.a)];
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // REM_S
 export const rem_s = (r, args, registers) => {
-    const b = i64(registers[reg(args.b)]);
-    const a = i64(registers[reg(args.a)]);
+    const b = i64(registers[Inst.reg(args.b)]);
+    const a = i64(registers[Inst.reg(args.a)]);
     if (a === i64(0)) {
-        registers[reg(args.c)] = u64(b);
+        registers[Inst.reg(args.c)] = u64(b);
     }
     else if (a === i64(-1) && b === i64.MIN_VALUE) {
-        registers[reg(args.c)] = u64(0);
+        registers[Inst.reg(args.c)] = u64(0);
     }
     else {
-        registers[reg(args.c)] = u64(b % a);
+        registers[Inst.reg(args.c)] = u64(b % a);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // MUL_UPPER_S_S
 export const mul_upper_s_s = (r, args, registers) => {
-    registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));
-    return ok(r);
+    registers[Inst.reg(args.c)] = mulUpperSigned(i64(registers[Inst.reg(args.b)]), i64(registers[Inst.reg(args.a)]));
+    return OutcomeData.ok(r);
 };
 // MUL_UPPER_U_U
 export const mul_upper_u_u = (r, args, registers) => {
-    registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);
-    return ok(r);
+    registers[Inst.reg(args.c)] = mulUpperUnsigned(registers[Inst.reg(args.b)], registers[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // MUL_UPPER_S_U
 export const mul_upper_s_u = (r, args, registers) => {
-    registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);
-    return ok(r);
+    registers[Inst.reg(args.c)] = mulUpperSignedUnsigned(i64(registers[Inst.reg(args.b)]), registers[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // MAX
 export const max = (r, args, registers) => {
-    const a = i64(registers[reg(args.a)]);
-    const b = i64(registers[reg(args.b)]);
-    registers[reg(args.c)] = u64(a < b ? b : a);
-    return ok(r);
+    const a = i64(registers[Inst.reg(args.a)]);
+    const b = i64(registers[Inst.reg(args.b)]);
+    registers[Inst.reg(args.c)] = u64(a < b ? b : a);
+    return OutcomeData.ok(r);
 };
 // MAX_U
 export const max_u = (r, args, registers) => {
-    const a = registers[reg(args.a)];
-    const b = registers[reg(args.b)];
-    registers[reg(args.c)] = a < b ? b : a;
-    return ok(r);
+    const a = registers[Inst.reg(args.a)];
+    const b = registers[Inst.reg(args.b)];
+    registers[Inst.reg(args.c)] = a < b ? b : a;
+    return OutcomeData.ok(r);
 };
 // MIN
 export const min = (r, args, registers) => {
-    const a = i64(registers[reg(args.a)]);
-    const b = i64(registers[reg(args.b)]);
-    registers[reg(args.c)] = u64(a > b ? b : a);
-    return ok(r);
+    const a = i64(registers[Inst.reg(args.a)]);
+    const b = i64(registers[Inst.reg(args.b)]);
+    registers[Inst.reg(args.c)] = u64(a > b ? b : a);
+    return OutcomeData.ok(r);
 };
 // MIN_U
 export const min_u = (r, args, registers) => {
-    const a = registers[reg(args.a)];
-    const b = registers[reg(args.b)];
-    registers[reg(args.c)] = a > b ? b : a;
-    return ok(r);
+    const a = registers[Inst.reg(args.a)];
+    const b = registers[Inst.reg(args.b)];
+    registers[Inst.reg(args.c)] = a > b ? b : a;
+    return OutcomeData.ok(r);
 };

package/dist/build/js/assembly/instructions/misc.js

@@ -1,22 +1,22 @@
 import { MaybePageFault } from "../memory";
-import { hostCall, ok, okOrFault, panic } from "./outcome";
-import { reg } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 const faultRes = new MaybePageFault();
 // INVALID
-export const INVALID = (r) => panic(r);
+export const INVALID = (r) => OutcomeData.panic(r);
 // TRAP
-export const trap = (r) => panic(r);
+export const trap = (r) => OutcomeData.panic(r);
 // FALLTHROUGH
-export const fallthrough = (r) => ok(r);
+export const fallthrough = (r) => OutcomeData.ok(r);
 // ECALLI
-export const ecalli = (r, args) => hostCall(r, args.a);
+export const ecalli = (r, args) => OutcomeData.hostCall(r, args.a);
 // SBRK
 export const sbrk = (r, args, registers, memory) => {
-    const res = memory.sbrk(faultRes, u32(registers[reg(args.a)]));
+    const res = memory.sbrk(faultRes, u32(registers[Inst.reg(args.a)]));
     // out of memory
     if (faultRes.isFault) {
-        return okOrFault(r, faultRes);
+        return OutcomeData.okOrFault(r, faultRes);
     }
-    registers[reg(args.b)] = res;
-    return ok(r);
+    registers[Inst.reg(args.b)] = res;
+    return OutcomeData.ok(r);
 };

package/dist/build/js/assembly/instructions/mov.js

@@ -1,35 +1,35 @@
-import { ok } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 // MOVE_REG
 export const move_reg = (r, args, registers) => {
-    registers[reg(args.b)] = registers[reg(args.a)];
-    return ok(r);
+    registers[Inst.reg(args.b)] = registers[Inst.reg(args.a)];
+    return OutcomeData.ok(r);
 };
 // CMOV_IZ_IMM
 export const cmov_iz_imm = (r, args, registers) => {
-    if (registers[reg(args.a)] === u64(0)) {
-        registers[reg(args.b)] = u32SignExtend(args.c);
+    if (registers[Inst.reg(args.a)] === u64(0)) {
+        registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // CMOV_NZ_IMM
 export const cmov_nz_imm = (r, args, registers) => {
-    if (registers[reg(args.a)] !== u64(0)) {
-        registers[reg(args.b)] = u32SignExtend(args.c);
+    if (registers[Inst.reg(args.a)] !== u64(0)) {
+        registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c);
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // CMOV_IZ
 export const cmov_iz = (r, args, registers) => {
-    if (registers[reg(args.a)] === u64(0)) {
-        registers[reg(args.c)] = registers[reg(args.b)];
+    if (registers[Inst.reg(args.a)] === u64(0)) {
+        registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)];
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };
 // CMOV_NZ
 export const cmov_nz = (r, args, registers) => {
-    if (registers[reg(args.a)] !== u64(0)) {
-        registers[reg(args.c)] = registers[reg(args.b)];
+    if (registers[Inst.reg(args.a)] !== u64(0)) {
+        registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)];
     }
-    return ok(r);
+    return OutcomeData.ok(r);
 };

package/dist/build/js/assembly/instructions/outcome.d.ts

@@ -20,11 +20,11 @@ export declare class OutcomeData {
     dJump: u32;
     result: Result;
     exitCode: u32;
+    static status(r: OutcomeData, result: Result): OutcomeData;
+    static staticJump(r: OutcomeData, offset: i32): OutcomeData;
+    static dJump(r: OutcomeData, address: u32): OutcomeData;
+    static ok(r: OutcomeData): OutcomeData;
+    static panic(r: OutcomeData): OutcomeData;
+    static hostCall(r: OutcomeData, id: u32): OutcomeData;
+    static okOrFault(r: OutcomeData, pageFault: MaybePageFault): OutcomeData;
 }
-export declare function status(r: OutcomeData, result: Result): OutcomeData;
-export declare function staticJump(r: OutcomeData, offset: i32): OutcomeData;
-export declare function dJump(r: OutcomeData, address: u32): OutcomeData;
-export declare function ok(r: OutcomeData): OutcomeData;
-export declare function panic(r: OutcomeData): OutcomeData;
-export declare function hostCall(r: OutcomeData, id: u32): OutcomeData;
-export declare function okOrFault(r: OutcomeData, pageFault: MaybePageFault): OutcomeData;

package/dist/build/js/assembly/instructions/outcome.js

@@ -1,3 +1,9 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 export var Result;
 (function (Result) {
     Result[Result["PANIC"] = 0] = "PANIC";
@@ -20,42 +26,63 @@ export class OutcomeData {
         this.result = Result.PANIC;
         this.exitCode = 0;
     }
-}
-export function status(r, result) {
-    r.outcome = Outcome.Result;
-    r.result = result;
-    return r;
-}
-export function staticJump(r, offset) {
-    r.outcome = Outcome.StaticJump;
-    r.staticJump = offset;
-    return r;
-}
-export function dJump(r, address) {
-    r.outcome = Outcome.DynamicJump;
-    r.dJump = address;
-    return r;
-}
-export function ok(r) {
-    // outcome is already pre-set to Ok by the interpreter loop
-    return r;
-}
-export function panic(r) {
-    return status(r, Result.PANIC);
-}
-export function hostCall(r, id) {
-    r.outcome = Outcome.Result;
-    r.result = Result.HOST;
-    r.exitCode = id;
-    return r;
-}
-export function okOrFault(r, pageFault) {
-    if (pageFault.isFault) {
+    static status(r, result) {
         r.outcome = Outcome.Result;
-        // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP
-        // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.
-        r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;
-        r.exitCode = pageFault.fault;
+        r.result = result;
+        return r;
+    }
+    static staticJump(r, offset) {
+        r.outcome = Outcome.StaticJump;
+        r.staticJump = offset;
+        return r;
+    }
+    static dJump(r, address) {
+        r.outcome = Outcome.DynamicJump;
+        r.dJump = address;
+        return r;
+    }
+    static ok(r) {
+        // outcome is already pre-set to Ok by the interpreter loop
+        return r;
+    }
+    static panic(r) {
+        return OutcomeData.status(r, Result.PANIC);
+    }
+    static hostCall(r, id) {
+        r.outcome = Outcome.Result;
+        r.result = Result.HOST;
+        r.exitCode = id;
+        return r;
+    }
+    static okOrFault(r, pageFault) {
+        if (pageFault.isFault) {
+            r.outcome = Outcome.Result;
+            // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP
+            // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.
+            r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;
+            r.exitCode = pageFault.fault;
+        }
+        return r;
     }
-    return r;
 }
+__decorate([
+    inline
+], OutcomeData, "status", null);
+__decorate([
+    inline
+], OutcomeData, "staticJump", null);
+__decorate([
+    inline
+], OutcomeData, "dJump", null);
+__decorate([
+    inline
+], OutcomeData, "ok", null);
+__decorate([
+    inline
+], OutcomeData, "panic", null);
+__decorate([
+    inline
+], OutcomeData, "hostCall", null);
+__decorate([
+    inline
+], OutcomeData, "okOrFault", null);

package/dist/build/js/assembly/instructions/rot.js

@@ -1,45 +1,45 @@
 import { portable } from "../portable";
-import { ok } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 // ROT_R_64_IMM
 export const rot_r_64_imm = (r, args, regs) => {
-    regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));
-    return ok(r);
+    regs[Inst.reg(args.b)] = math.rot_r(regs[Inst.reg(args.a)], Inst.u32SignExtend(args.c));
+    return OutcomeData.ok(r);
 };
 // ROT_R_64_IMM_ALT
 export const rot_r_64_imm_alt = (r, args, regs) => {
-    regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.b)] = math.rot_r(Inst.u32SignExtend(args.c), regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // ROT_R_32_IMM
 export const rot_r_32_imm = (r, args, regs) => {
-    regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));
-    return ok(r);
+    regs[Inst.reg(args.b)] = Inst.u32SignExtend(math.rot_r_32(u32(regs[Inst.reg(args.a)]), u32(args.c)));
+    return OutcomeData.ok(r);
 };
 // ROT_R_32_IMM_ALT
 export const rot_r_32_imm_alt = (r, args, regs) => {
-    regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.b)] = Inst.u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 // ROT_L_64
 export const rot_l_64 = (r, args, regs) => {
-    regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.c)] = math.rot_l(regs[Inst.reg(args.b)], regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // ROT_L_32
 export const rot_l_32 = (r, args, regs) => {
-    regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.c)] = Inst.u32SignExtend(math.rot_l_32(u32(regs[Inst.reg(args.b)]), u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 // ROT_R_64
 export const rot_r_64 = (r, args, regs) => {
-    regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);
-    return ok(r);
+    regs[Inst.reg(args.c)] = math.rot_r(regs[Inst.reg(args.b)], regs[Inst.reg(args.a)]);
+    return OutcomeData.ok(r);
 };
 // ROT_R_32
 export const rot_r_32 = (r, args, regs) => {
-    regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));
-    return ok(r);
+    regs[Inst.reg(args.c)] = Inst.u32SignExtend(math.rot_r_32(u32(regs[Inst.reg(args.b)]), u32(regs[Inst.reg(args.a)])));
+    return OutcomeData.ok(r);
 };
 export var math;
 (function (math) {

package/dist/build/js/assembly/instructions/set.js

@@ -1,36 +1,36 @@
-import { ok } from "./outcome";
-import { reg, u32SignExtend } from "./utils";
+import { OutcomeData } from "./outcome";
+import { Inst } from "./utils";
 // SET_LT_U_IMM
 export const set_lt_u_imm = (r, args, registers) => {
-    const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));
-    registers[reg(args.b)] = cond ? u64(1) : u64(0);
-    return ok(r);
+    const cond = registers[Inst.reg(args.a)] < u64(Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_LT_S_IMM
 export const set_lt_s_imm = (r, args, registers) => {
-    const cond = i64(registers[reg(args.a)]) < i64(u32SignExtend(args.c));
-    registers[reg(args.b)] = cond ? u64(1) : u64(0);
-    return ok(r);
+    const cond = i64(registers[Inst.reg(args.a)]) < i64(Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_GT_U_IMM
 export const set_gt_u_imm = (r, args, registers) => {
-    const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));
-    registers[reg(args.b)] = cond ? u64(1) : u64(0);
-    return ok(r);
+    const cond = registers[Inst.reg(args.a)] > u64(Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_GT_S_IMM
 export const set_gt_s_imm = (r, args, registers) => {
-    const cond = i64(registers[reg(args.a)]) > i64(u32SignExtend(args.c));
-    registers[reg(args.b)] = cond ? u64(1) : u64(0);
-    return ok(r);
+    const cond = i64(registers[Inst.reg(args.a)]) > i64(Inst.u32SignExtend(args.c));
+    registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_LT_U
 export const set_lt_u = (r, args, registers) => {
-    registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? u64(1) : u64(0);
-    return ok(r);
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] < registers[Inst.reg(args.a)] ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };
 // SET_LT_S
 export const set_lt_s = (r, args, registers) => {
-    registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? u64(1) : u64(0);
-    return ok(r);
+    registers[Inst.reg(args.c)] = i64(registers[Inst.reg(args.b)]) < i64(registers[Inst.reg(args.a)]) ? u64(1) : u64(0);
+    return OutcomeData.ok(r);
 };