@grain/stdlib 0.4.4 → 0.5.0

package/runtime/numbers.gr

@@ -1,18 +1,23 @@
-/* grainc-flags --compilation-mode=runtime */
+/* grainc-flags --no-pervasives */
 
 import Memory from "runtime/unsafe/memory"
 import Tags from "runtime/unsafe/tags"
 import Exception from "runtime/exception"
+import BI from "runtime/bigint"
 
+import {
+  _SMAX32_I64 as _I32_MAX,
+  _SMIN32_I64 as _I32_MIN,
+} from "runtime/unsafe/constants"
 import WasmI32 from "runtime/unsafe/wasmi32"
 import WasmI64 from "runtime/unsafe/wasmi64"
 import WasmF32 from "runtime/unsafe/wasmf32"
 import WasmF64 from "runtime/unsafe/wasmf64"
 
-primitive (!) : Bool -> Bool = "@not"
-primitive (&&) : (Bool, Bool) -> Bool = "@and"
-primitive (||) : (Bool, Bool) -> Bool = "@or"
-primitive throw : Exception -> a = "@throw"
+primitive (!): Bool -> Bool = "@not"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
+primitive (||): (Bool, Bool) -> Bool = "@or"
+primitive throw: Exception -> a = "@throw"
 
 exception UnknownNumberTag
 
@@ -21,60 +26,82 @@ import {
   newInt32,
   newInt64,
   newFloat32,
-  newFloat64
+  newFloat64,
 } from "runtime/dataStructures"
 
-export newRational
-export newInt32
-export newInt64
-export newFloat32
-export newFloat64
-
-let _I32_MAX = 0x7fffffffN
-let _I32_MIN = -0x7fffffffN
+@unsafe
 let _F32_MAX = 3.40282347e+38W
+@unsafe
 let _F32_MIN = 1.401298464324817e-45W
+@unsafe
 let _F32_MAX_SAFE_INTEGER = 16777215.w
+@unsafe
 let _F64_MAX_SAFE_INTEGER = 9007199254740991.W
 
 let (==) = WasmI32.eq
 let (!=) = WasmI32.ne
 
-let tagSimple = (x) => {
+@unsafe
+let tagSimple = x => {
   WasmI32.xor(WasmI32.shl(x, 1n), 1n)
 }
 
-let untagSimple = (x) => {
+@unsafe
+let untagSimple = x => {
   WasmI32.shrS(x, 1n)
 }
 
-let isSimpleNumber = (x) => {
-  WasmI32.eq(WasmI32.and(x, Tags._GRAIN_NUMBER_TAG_MASK), Tags._GRAIN_NUMBER_TAG_TYPE)
+@unsafe
+let isSimpleNumber = x => {
+  WasmI32.eq(
+    WasmI32.and(x, Tags._GRAIN_NUMBER_TAG_MASK),
+    Tags._GRAIN_NUMBER_TAG_TYPE
+  )
 }
 
-export let isBoxedNumber = (x) => {
-  if (WasmI32.eq(WasmI32.and(x, Tags._GRAIN_GENERIC_TAG_MASK), Tags._GRAIN_GENERIC_HEAP_TAG_TYPE)) {
+@unsafe
+export let isBoxedNumber = x => {
+  if (
+    WasmI32.eq(
+      WasmI32.and(x, Tags._GRAIN_GENERIC_TAG_MASK),
+      Tags._GRAIN_GENERIC_HEAP_TAG_TYPE
+    )
+  ) {
     WasmI32.eq(WasmI32.load(x, 0n), Tags._GRAIN_BOXED_NUM_HEAP_TAG)
   } else {
     false
   }
 }
 
-export let isFloat = (x) => {
+@unsafe
+export let isFloat = x => {
   if (isBoxedNumber(x)) {
     let tag = WasmI32.load(x, 4n)
-    WasmI32.eq(tag, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) || WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
+    WasmI32.eq(tag, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) ||
+    WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
   } else {
     false
   }
 }
 
-export let isNumber = (x) => {
+@unsafe
+let isBigInt = x => {
+  if (isBoxedNumber(x)) {
+    let tag = WasmI32.load(x, 4n)
+    WasmI32.eq(tag, Tags._GRAIN_BIGINT_BOXED_NUM_TAG)
+  } else {
+    false
+  }
+}
+
+@unsafe
+export let isNumber = x => {
   // x is a number if it is a literal number or a boxed_num heap value
   isSimpleNumber(x) || isBoxedNumber(x)
 }
 
-let safeI64toI32 = (x) => {
+@unsafe
+let safeI64toI32 = x => {
   if (WasmI64.gtS(x, _I32_MAX) || WasmI64.ltS(x, _I32_MIN)) {
     throw Exception.Overflow
   } else {
@@ -82,12 +109,16 @@ let safeI64toI32 = (x) => {
   }
 }
 
-let i32neg = (x) => WasmI32.sub(0n, x)
+@unsafe
+let i32neg = x => WasmI32.sub(0n, x)
 
-let i64not = (x) => WasmI64.xor(x, 0xffffffffffffffffN)
-let i64neg = (x) => WasmI64.sub(0N, x)
+@unsafe
+let i64not = x => WasmI64.xor(x, 0xffffffffffffffffN)
+@unsafe
+let i64neg = x => WasmI64.sub(0N, x)
 
 // https://en.wikipedia.org/wiki/Binary_GCD_algorithm
+@unsafe
 let rec gcdHelp = (x, y) => {
   if (WasmI64.eq(x, y) || WasmI64.eqz(x)) {
     y
@@ -111,6 +142,7 @@ let rec gcdHelp = (x, y) => {
   }
 }
 
+@unsafe
 let gcd = (x, y) => {
   // Algorithm above breaks on negatives, so
   // we make sure that they are positive at the beginning
@@ -127,43 +159,90 @@ let gcd = (x, y) => {
   gcdHelp(x, y)
 }
 
+@unsafe
 let gcd32 = (x, y) => {
   WasmI32.wrapI64(gcd(WasmI64.extendI32S(x), WasmI64.extendI32S(y)))
 }
 
-export let reducedInteger = (x) => {
+@unsafe
+export let reducedInteger = x => {
   if (WasmI64.gtS(x, _I32_MAX) || WasmI64.ltS(x, _I32_MIN)) {
     newInt64(x)
-  } else if (WasmI64.gtS(x, WasmI64.shrS(_I32_MAX, 1N)) || WasmI64.ltS(x, WasmI64.shrS(_I32_MIN, 1N))) {
+  } else if (
+    WasmI64.gtS(x, WasmI64.shrS(_I32_MAX, 1N)) ||
+    WasmI64.ltS(x, WasmI64.shrS(_I32_MIN, 1N))
+  ) {
     newInt32(WasmI32.wrapI64(x))
   } else {
     tagSimple(WasmI32.wrapI64(x))
   }
 }
 
-let reducedFraction = (x, y) => {
+@unsafe
+let reducedBigInteger = x => {
+  if (BI.canConvertToInt64(x)) {
+    // CONVENTION: We assume that this function is called in
+    //             some sort of tail position, meaning that
+    //             the original input is no longer used after
+    //             this function returns.
+    let ret = reducedInteger(BI.toInt64(x))
+    Memory.decRef(x)
+    ret
+  } else {
+    x
+  }
+}
+
+@unsafe
+let reducedFractionBigInt = (x, y) => {
   let mut x = x
   let mut y = y
+  let mut needsDecref = false
 
-  if (WasmI32.ltS(y, 0n)) {
+  if (BI.isNegative(y)) {
     // Normalization 1: Never do negative/negative
     // Normalization 2: Never allow a negative denominator
-    x = i32neg(x)
-    y = i32neg(y)
+    needsDecref = true
+    x = BI.negate(x)
+    y = BI.negate(y)
   }
-  if (WasmI32.eqz(y)) {
+  if (BI.eqz(y)) {
     throw Exception.DivisionByZero
   }
-  if (WasmI32.eqz(WasmI32.remS(x, y))) {
-    // Avoid allocation if possible
-    reducedInteger(WasmI64.extendI32S(WasmI32.divS(x, y)))
+  let quotremResult = Memory.malloc(8n)
+  BI.quotRem(x, y, quotremResult)
+  // Note that the contents of quotRem are malloc'ed
+  // inside of quotRem and need to be manually freed.
+  let q = WasmI32.load(quotremResult, 0n)
+  let r = WasmI32.load(quotremResult, 4n)
+  // free container used to store quotrem result
+  Memory.free(quotremResult)
+  let ret = if (BI.eqz(r)) {
+    // if remainder is zero, then return the quotient.
+    // We decRef the remainder, since we no longer need it
+    Memory.decRef(r)
+    reducedBigInteger(q)
   } else {
-    // x not evenly divisible by y
-    let factor = gcd32(x, y)
-    newRational(WasmI32.divS(x, factor), WasmI32.divS(y, factor))
+    // remainder is nonzero. we don't need the quotient and
+    // remainder anymore, so we discard them.
+    Memory.decRef(q)
+    Memory.decRef(r)
+    let factor = BI.gcd(x, y)
+    let xdiv = BI.div(x, factor)
+    let ydiv = BI.div(y, factor)
+    let ret = newRational(xdiv, ydiv)
+    Memory.decRef(factor)
+    ret
+  }
+  if (needsDecref) {
+    Memory.decRef(x)
+    Memory.decRef(y)
+    void
   }
+  ret
 }
 
+@unsafe
 let reducedFraction64 = (x, y) => {
   let mut x = x
   let mut y = y
@@ -181,28 +260,10 @@ let reducedFraction64 = (x, y) => {
     reducedInteger(WasmI64.divS(x, y))
   } else {
     let factor = gcd(x, y)
-    let xdiv = safeI64toI32(WasmI64.divS(x, factor))
-    let ydiv = safeI64toI32(WasmI64.divS(y, factor))
-    newRational(xdiv, ydiv)
-  }
-}
-
-let safeI32Multiply = (x, y) => {
-  let prod = WasmI64.mul(WasmI64.extendI32S(x), WasmI64.extendI32S(y))
-  if (WasmI64.gtS(prod, _I32_MAX) || WasmI64.ltS(prod, _I32_MIN)) {
-    throw Exception.Overflow
+    let xdiv = WasmI64.divS(x, factor)
+    let ydiv = WasmI64.divS(y, factor)
+    newRational(BI.makeWrappedInt64(xdiv), BI.makeWrappedInt64(ydiv))
   }
-  WasmI32.wrapI64(prod)
-}
-
-let safeI64Multiply = (x, y) => {
-  let prod = WasmI64.mul(x, y)
-  if (WasmI64.ne(x, 0N)) {
-    if (WasmI64.ne(WasmI64.divS(prod, x), y)) {
-      throw Exception.Overflow
-    }
-  }
-  prod
 }
 
 // Accessor functions
@@ -228,36 +289,42 @@ let safeI64Multiply = (x, y) => {
  * [numerator, denominator]
  */
 
-export let boxedNumberTag = (xptr) => {
+@unsafe
+export let boxedNumberTag = xptr => {
   WasmI32.load(xptr, 4n)
 }
 
-export let boxedInt32Number = (xptr) => {
+@unsafe
+export let boxedInt32Number = xptr => {
   WasmI32.load(xptr, 8n)
 }
 
-export let boxedInt64Number = (xptr) => {
+@unsafe
+export let boxedInt64Number = xptr => {
   WasmI64.load(xptr, 8n)
 }
 
-export let boxedFloat32Number = (xptr) => {
+@unsafe
+export let boxedFloat32Number = xptr => {
   WasmF32.load(xptr, 8n)
 }
 
-export let boxedFloat64Number = (xptr) => {
+@unsafe
+export let boxedFloat64Number = xptr => {
   WasmF64.load(xptr, 8n)
 }
 
-export let boxedRationalNumerator = (xptr) => {
+@unsafe
+export let boxedRationalNumerator = xptr => {
   WasmI32.load(xptr, 8n)
 }
 
-export let boxedRationalDenominator = (xptr) => {
+@unsafe
+export let boxedRationalDenominator = xptr => {
   WasmI32.load(xptr, 12n)
 }
 
-
-
+@unsafe
 export let coerceNumberToWasmF32 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
   if (isSimpleNumber(x)) {
@@ -271,8 +338,14 @@ export let coerceNumberToWasmF32 = (x: Number) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         WasmF32.convertI64S(boxedInt64Number(x))
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        BI.toFloat32(x)
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
-        WasmF32.div(WasmF32.convertI32S(boxedRationalNumerator(x)), WasmF32.convertI32S(boxedRationalDenominator(x)))
+        WasmF32.div(
+          BI.toFloat32(boxedRationalNumerator(x)),
+          BI.toFloat32(boxedRationalDenominator(x))
+        )
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         boxedFloat32Number(x)
@@ -288,11 +361,12 @@ export let coerceNumberToWasmF32 = (x: Number) => {
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 export let coerceNumberToWasmF64 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
   if (isSimpleNumber(x)) {
@@ -306,8 +380,14 @@ export let coerceNumberToWasmF64 = (x: Number) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         WasmF64.convertI64S(boxedInt64Number(x))
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        BI.toFloat64(x)
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
-        WasmF64.div(WasmF64.convertI32S(boxedRationalNumerator(x)), WasmF64.convertI32S(boxedRationalDenominator(x)))
+        WasmF64.div(
+          BI.toFloat64(boxedRationalNumerator(x)),
+          BI.toFloat64(boxedRationalDenominator(x))
+        )
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         WasmF64.promoteF32(boxedFloat32Number(x))
@@ -317,11 +397,12 @@ export let coerceNumberToWasmF64 = (x: Number) => {
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 export let coerceNumberToWasmI64 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
   if (isSimpleNumber(x)) {
@@ -335,14 +416,18 @@ export let coerceNumberToWasmI64 = (x: Number) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         boxedInt64Number(x)
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        BI.toInt64(x)
+      },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
         throw Exception.NumberNotIntlike
-      }
+      },
     }
   }
 }
 
+@unsafe
 export let coerceNumberToWasmI32 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
   if (isSimpleNumber(x)) {
@@ -360,29 +445,63 @@ export let coerceNumberToWasmI32 = (x: Number) => {
         }
         WasmI32.wrapI64(int64)
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        BI.toInt32(x)
+      },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
         throw Exception.NumberNotIntlike
-      }
+      },
     }
   }
 }
 
+@unsafe
+export let coerceNumberToBigInt = (x: Number) => {
+  let x = WasmI32.fromGrain(x)
+  if (isSimpleNumber(x)) {
+    BI.makeWrappedInt32(untagSimple(x))
+  } else {
+    let xtag = boxedNumberTag(x)
+    match (xtag) {
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        BI.makeWrappedInt32(boxedInt32Number(x))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+        BI.makeWrappedInt64(boxedInt64Number(x))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        Memory.incRef(x)
+        x
+      },
+      _ => {
+        // rationals are never integral, and we refuse to coerce floats to ints
+        throw Exception.NumberNotIntlike
+      },
+    }
+  }
+}
 
-let isIntegerF32 = (value) => {
+@unsafe
+let isIntegerF32 = value => {
   WasmF32.eq(value, WasmF32.trunc(value))
 }
 
-let isIntegerF64 = (value) => {
+@unsafe
+let isIntegerF64 = value => {
   WasmF64.eq(value, WasmF64.trunc(value))
 }
 
-let isSafeIntegerF32 = (value) => {
-  WasmF32.le(WasmF32.abs(value), _F32_MAX_SAFE_INTEGER) && WasmF32.eq(WasmF32.trunc(value), value)
+@unsafe
+let isSafeIntegerF32 = value => {
+  WasmF32.le(WasmF32.abs(value), _F32_MAX_SAFE_INTEGER) &&
+  WasmF32.eq(WasmF32.trunc(value), value)
 }
 
-let isSafeIntegerF64 = (value) => {
-  WasmF64.le(WasmF64.abs(value), _F64_MAX_SAFE_INTEGER) && WasmF64.eq(WasmF64.trunc(value), value)
+@unsafe
+let isSafeIntegerF64 = value => {
+  WasmF64.le(WasmF64.abs(value), _F64_MAX_SAFE_INTEGER) &&
+  WasmF64.eq(WasmF64.trunc(value), value)
 }
 
 /** Number-aware equality checking
@@ -394,6 +513,7 @@ let isSafeIntegerF64 = (value) => {
   *       export them!
   */
 
+@unsafe
 let numberEqualSimpleHelp = (x, y) => {
   // PRECONDITION: x is a "simple" number (value tag is 0) and x !== y and isNumber(y)
   if (isSimpleNumber(y)) {
@@ -411,26 +531,31 @@ let numberEqualSimpleHelp = (x, y) => {
         let yBoxedVal = boxedInt64Number(y)
         WasmI64.eq(WasmI64.extendI32S(xval), yBoxedVal)
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        WasmI32.eqz(BI.cmpI64(y, WasmI64.extendI32S(xval)))
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         // NOTE: we always store in most reduced form, so a rational and an int are never equal
         false
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
-        isSafeIntegerF32(yBoxedVal) && WasmF32.eq(WasmF32.convertI32S(xval), yBoxedVal)
+        isSafeIntegerF32(yBoxedVal) &&
+        WasmF32.eq(WasmF32.convertI32S(xval), yBoxedVal)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
-        isSafeIntegerF64(yBoxedVal) && WasmF64.eq(WasmF64.convertI32S(xval), yBoxedVal)
+        isSafeIntegerF64(yBoxedVal) &&
+        WasmF64.eq(WasmF64.convertI32S(xval), yBoxedVal)
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
-
+@unsafe
 let numberEqualInt64Help = (xBoxedVal, y) => {
   // PRECONDITION: x !== y and isNumber(y)
   // Basic number:
@@ -448,30 +573,37 @@ let numberEqualInt64Help = (xBoxedVal, y) => {
         let yBoxedVal = boxedInt64Number(y)
         WasmI64.eq(xBoxedVal, yBoxedVal)
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        WasmI32.eqz(BI.cmpI64(y, xBoxedVal))
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         // NOTE: we always store in most reduced form, so a rational and an int are never equal
         false
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
-        isSafeIntegerF32(yBoxedVal) && WasmI64.eq(xBoxedVal, WasmI64.truncF32S(yBoxedVal))
+        isSafeIntegerF32(yBoxedVal) &&
+        WasmI64.eq(xBoxedVal, WasmI64.truncF32S(yBoxedVal))
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
-        isSafeIntegerF64(yBoxedVal) && WasmI64.eq(xBoxedVal, WasmI64.truncF64S(yBoxedVal))
+        isSafeIntegerF64(yBoxedVal) &&
+        WasmI64.eq(xBoxedVal, WasmI64.truncF64S(yBoxedVal))
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 let numberEqualInt32Help = (xBoxedVal, y) => {
   // We can just pretend it's 64-bit for the equality check
   numberEqualInt64Help(WasmI64.extendI32S(xBoxedVal), y)
 }
 
+@unsafe
 let numberEqualRationalHelp = (xptr, y) => {
   // PRECONDITION: x is rational and x !== y and isNumber(y)
   // Basic number: (we know it's not equal, since we never store ints as rationals)
@@ -489,30 +621,40 @@ let numberEqualRationalHelp = (xptr, y) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         false
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        false
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
-        WasmI32.eq(xNumerator, yNumerator) && WasmI32.eq(xDenominator, yDenominator)
+        BI.eq(xNumerator, yNumerator) && BI.eq(xDenominator, yDenominator)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
-        let xAsFloat = WasmF32.div(WasmF32.convertI32S(xNumerator), WasmF32.convertI32S(xDenominator))
+        let xAsFloat = WasmF32.div(
+          BI.toFloat32(xNumerator),
+          BI.toFloat32(xDenominator)
+        )
         // TODO: (#303) maybe we should have some sort of tolerance?
         WasmF32.eq(xAsFloat, yBoxedVal)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
-        let xAsFloat = WasmF64.div(WasmF64.convertI32S(xNumerator), WasmF64.convertI32S(xDenominator))
+        let xAsFloat = WasmF64.div(
+          BI.toFloat64(xNumerator),
+          BI.toFloat64(xDenominator)
+        )
         // TODO: (#303) maybe we should have some sort of tolerance?
         WasmF64.eq(xAsFloat, yBoxedVal)
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 let numberEqualFloat64Help = (x, y) => {
   let xIsInteger = isIntegerF64(x)
   // Basic number:
@@ -530,10 +672,16 @@ let numberEqualFloat64Help = (x, y) => {
         let yBoxedVal = boxedInt64Number(y)
         isSafeIntegerF64(x) && WasmF64.eq(x, WasmF64.convertI64S(yBoxedVal))
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        WasmI32.eqz(BI.cmpF64(y, x))
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         let yNumerator = boxedRationalNumerator(y)
         let yDenominator = boxedRationalDenominator(y)
-        let yAsFloat = WasmF64.div(WasmF64.convertI32S(yNumerator), WasmF64.convertI32S(yDenominator))
+        let yAsFloat = WasmF64.div(
+          BI.toFloat64(yNumerator),
+          BI.toFloat64(yDenominator)
+        )
         WasmF64.eq(x, yAsFloat)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
@@ -548,11 +696,12 @@ let numberEqualFloat64Help = (x, y) => {
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 let numberEqualFloat32Help = (x, y) => {
   let xIsInteger = isIntegerF32(x)
   // Basic number:
@@ -568,11 +717,50 @@ let numberEqualFloat32Help = (x, y) => {
       },
       _ => {
         numberEqualFloat64Help(WasmF64.promoteF32(x), y)
-      }
+      },
+    }
+  }
+}
+
+@unsafe
+let numberEqualBigIntHelp = (x, y) => {
+  if (isSimpleNumber(y)) {
+    WasmI32.eqz(BI.cmpI64(x, WasmI64.extendI32S(untagSimple(y))))
+  } else {
+    // Boxed number
+    let yBoxedNumberTag = boxedNumberTag(y)
+    match (yBoxedNumberTag) {
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        let yBoxedVal = boxedInt32Number(y)
+        WasmI32.eqz(BI.cmpI64(x, WasmI64.extendI32S(yBoxedVal)))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+        let yBoxedVal = boxedInt64Number(y)
+        WasmI32.eqz(BI.cmpI64(x, yBoxedVal))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        BI.eq(x, y)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+        // Rationals are reduced, so it must be unequal
+        false
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+        let yBoxedVal = boxedFloat32Number(y)
+        WasmI32.eqz(BI.cmpF32(x, yBoxedVal))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+        let yBoxedVal = boxedFloat64Number(y)
+        WasmI32.eqz(BI.cmpF64(x, yBoxedVal))
+      },
+      _ => {
+        throw UnknownNumberTag
+      },
     }
   }
 }
 
+@unsafe
 export let numberEqual = (x, y) => {
   if (isSimpleNumber(x)) {
     // Short circuit if non-pointer value is the same
@@ -598,9 +786,12 @@ export let numberEqual = (x, y) => {
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         numberEqualFloat64Help(boxedFloat64Number(x), y)
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        numberEqualBigIntHelp(x, y)
+      },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
@@ -610,6 +801,7 @@ export let numberEqual = (x, y) => {
  * (same schema as equal())
  */
 
+@unsafe
 let numberAddSubSimpleHelp = (x, y, isSub) => {
   // PRECONDITION: x is a "simple" number (value tag is 0) and isNumber(y)
   if (isSimpleNumber(y)) {
@@ -628,209 +820,424 @@ let numberAddSubSimpleHelp = (x, y, isSub) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         let xval = WasmI64.extendI32S(xval)
         let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
-        let result = if (isSub) WasmI64.sub(xval, yBoxedVal) else WasmI64.add(xval, yBoxedVal)
+        let result = if (isSub) WasmI64.sub(xval, yBoxedVal)
+          else WasmI64.add(xval, yBoxedVal)
         reducedInteger(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedInt64Number(y)
         let xval64 = WasmI64.extendI32S(xval)
-        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal) else WasmI64.add(xval64, yBoxedVal)
-        if (WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64)) {
-          throw Exception.Overflow
-        } else if (WasmI64.ltS(yBoxedVal, 0N) && WasmI64.gtS(result, xval64)) {
-          throw Exception.Overflow
+        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal)
+          else WasmI64.add(xval64, yBoxedVal)
+        if (
+          WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64) ||
+          WasmI64.ltS(yBoxedVal, 0N) && WasmI64.gtS(result, xval64)
+        ) {
+          // Overflow. Promote to BigInt
+          let xBig = BI.makeWrappedInt32(xval)
+          let yBig = BI.makeWrappedInt64(yBoxedVal)
+          let res = if (isSub) {
+            BI.sub(xBig, yBig)
+          } else {
+            BI.add(xBig, yBig)
+          }
+          Memory.decRef(xBig)
+          Memory.decRef(yBig)
+          reducedBigInteger(res)
         } else {
           reducedInteger(result)
         }
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        // Promote x to bigint and do operation
+        let xBig = BI.makeWrappedInt32(xval)
+        let result = if (isSub) BI.sub(xBig, y) else BI.add(xBig, y)
+        Memory.decRef(xBig)
+        reducedBigInteger(result)
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
-        let yNumerator = WasmI64.extendI32S(boxedRationalNumerator(y))
-        let yDenominator = WasmI64.extendI32S(boxedRationalDenominator(y))
-        let expandedXNumerator = safeI64Multiply(WasmI64.extendI32S(xval), yDenominator)
-        let result = if (isSub) WasmI64.sub(expandedXNumerator, yNumerator) else WasmI64.add(expandedXNumerator, yNumerator)
-        if (WasmI64.ltS(result, _I32_MIN) || WasmI64.gtS(result, _I32_MAX)) {
-          throw Exception.Overflow
-        }
-        reducedFraction64(result, yDenominator)
+        let xBig = BI.makeWrappedInt32(xval)
+        let yNumerator = boxedRationalNumerator(y)
+        let yDenominator = boxedRationalDenominator(y)
+        let expandedXNumerator = BI.mul(xBig, yDenominator)
+        Memory.decRef(xBig)
+        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+          else BI.add(expandedXNumerator, yNumerator)
+        let ret = reducedFractionBigInt(result, yDenominator)
+        Memory.decRef(expandedXNumerator)
+        Memory.decRef(result)
+        ret
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat32Number(y)
         let xval = WasmF32.convertI32S(xval)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal) else WasmF32.add(xval, yBoxedVal)
+        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+          else WasmF32.add(xval, yBoxedVal)
         // TODO: (#304) is this safe?
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedFloat64Number(y)
         let xval = WasmF64.convertI32S(xval)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal) else WasmF64.add(xval, yBoxedVal)
+        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+          else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 let numberAddSubInt64Help = (xval, y, isSub) => {
   if (isSimpleNumber(y)) {
     let yval = WasmI64.extendI32S(untagSimple(y))
     let result = if (isSub) WasmI64.sub(xval, yval) else WasmI64.add(xval, yval)
-    if (WasmI64.geS(yval, 0N) && WasmI64.ltS(result, xval)) {
-      throw Exception.Overflow
-    } else if (WasmI64.ltS(yval, 0N) && WasmI64.gtS(result, xval)) {
-      throw Exception.Overflow
+    if (
+      WasmI64.geS(yval, 0N) && WasmI64.ltS(result, xval) ||
+      WasmI64.ltS(yval, 0N) && WasmI64.gtS(result, xval)
+    ) {
+      // Overflow. Promote to BigInt
+      let xBig = BI.makeWrappedInt64(xval)
+      let yBig = BI.makeWrappedInt64(yval)
+      let res = if (isSub) {
+        BI.sub(xBig, yBig)
+      } else {
+        BI.add(xBig, yBig)
+      }
+      Memory.decRef(xBig)
+      Memory.decRef(yBig)
+      reducedBigInteger(res)
+    } else {
+      reducedInteger(result)
     }
-    reducedInteger(result)
   } else {
     let yBoxedNumberTag = boxedNumberTag(y)
     match (yBoxedNumberTag) {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
-        let result = if (isSub) WasmI64.sub(xval, yBoxedVal) else WasmI64.add(xval, yBoxedVal)
+        let result = if (isSub) WasmI64.sub(xval, yBoxedVal)
+          else WasmI64.add(xval, yBoxedVal)
         reducedInteger(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         let yBoxedVal = boxedInt64Number(y)
         let xval64 = xval
-        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal) else WasmI64.add(xval64, yBoxedVal)
-        if (WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64)) {
-          throw Exception.Overflow
-        } else if (WasmI64.ltS(yBoxedVal, 0N) && WasmI64.gtS(result, xval64)) {
-          throw Exception.Overflow
+        let result = if (isSub) WasmI64.sub(xval64, yBoxedVal)
+          else WasmI64.add(xval64, yBoxedVal)
+        if (
+          WasmI64.geS(yBoxedVal, 0N) && WasmI64.ltS(result, xval64) ||
+          WasmI64.ltS(yBoxedVal, 0N) && WasmI64.gtS(result, xval64)
+        ) {
+          // Overflow. Promote to BigInt
+          let xBig = BI.makeWrappedInt64(xval64)
+          let yBig = BI.makeWrappedInt64(yBoxedVal)
+          let res = if (isSub) {
+            BI.sub(xBig, yBig)
+          } else {
+            BI.add(xBig, yBig)
+          }
+          Memory.decRef(xBig)
+          Memory.decRef(yBig)
+          reducedBigInteger(res)
         } else {
           reducedInteger(result)
         }
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        // Promote x to bigint and do operation
+        let xBig = BI.makeWrappedInt64(xval)
+        let result = if (isSub) BI.sub(xBig, y) else BI.add(xBig, y)
+        Memory.decRef(xBig)
+        reducedBigInteger(result)
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
-        let yNumerator = WasmI64.extendI32S(boxedRationalNumerator(y))
-        let yDenominator = WasmI64.extendI32S(boxedRationalDenominator(y))
-        let expandedXNumerator = safeI64Multiply(xval, yDenominator)
-        let result = if (isSub) WasmI64.sub(expandedXNumerator, yNumerator) else WasmI64.add(expandedXNumerator, yNumerator)
-        if (WasmI64.ltS(result, _I32_MIN) || WasmI64.gtS(result, _I32_MAX)) {
-          throw Exception.Overflow
-        }
-        reducedFraction64(result, yDenominator)
+        let xBig = BI.makeWrappedInt64(xval)
+        let yNumerator = boxedRationalNumerator(y)
+        let yDenominator = boxedRationalDenominator(y)
+        let expandedXNumerator = BI.mul(xBig, yDenominator)
+        Memory.decRef(xBig)
+        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+          else BI.add(expandedXNumerator, yNumerator)
+        let ret = reducedFractionBigInt(result, yDenominator)
+        Memory.decRef(expandedXNumerator)
+        Memory.decRef(result)
+        ret
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = WasmF32.convertI64S(xval)
         let yBoxedVal = boxedFloat32Number(y)
-        let result = if (isSub) WasmF32.sub(xval, yBoxedVal) else WasmF32.add(xval, yBoxedVal)
-        // TODO: (#304) this isn't safe enough
+        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+          else WasmF32.add(xval, yBoxedVal)
+        // TODO(#304): this isn't safe enough
         newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
         let xval = WasmF64.convertI64S(xval)
         let yBoxedVal = boxedFloat64Number(y)
-        let result = if (isSub) WasmF64.sub(xval, yBoxedVal) else WasmF64.add(xval, yBoxedVal)
+        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+          else WasmF64.add(xval, yBoxedVal)
         newFloat64(result)
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 let numberAddSubFloat32Help = (xval, y, isSub) => {
-  if (!isSimpleNumber(y) && WasmI32.eq(boxedNumberTag(y), Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)) {
+  if (
+    !isSimpleNumber(y) &&
+    WasmI32.eq(boxedNumberTag(y), Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
+  ) {
     // Special case: promote to f64 if RHS is f64
     let xval = WasmF64.promoteF32(xval)
     let yval = boxedFloat64Number(y)
     let result = if (isSub) WasmF64.sub(xval, yval) else WasmF64.add(xval, yval)
     newFloat64(result)
   } else {
-    let yval = coerceNumberToWasmF32(WasmI32.toGrain(y) : Number)
+    // incRef y to reuse it via WasmI32.toGrain
+    Memory.incRef(y)
+    let yval = coerceNumberToWasmF32(WasmI32.toGrain(y): Number)
     let result = if (isSub) WasmF32.sub(xval, yval) else WasmF32.add(xval, yval)
     newFloat32(result)
   }
 }
 
+@unsafe
 let numberAddSubFloat64Help = (xval, y, isSub) => {
-  let yval = coerceNumberToWasmF64(WasmI32.toGrain(y) : Number)
+  // incRef y to reuse it via WasmI32.toGrain
+  Memory.incRef(y)
+  let yval = coerceNumberToWasmF64(WasmI32.toGrain(y): Number)
   let result = if (isSub) WasmF64.sub(xval, yval) else WasmF64.add(xval, yval)
   newFloat64(result)
 }
 
-
+@unsafe
 let numberAddSubInt32Help = (xval, y, isSub) => {
   numberAddSubInt64Help(WasmI64.extendI32S(xval), y, isSub)
 }
 
-let rec numberAddSubHelp = (x, y, isSub) => {
-  if (isSimpleNumber(x)) {
-    numberAddSubSimpleHelp(x, y, isSub)
+@unsafe
+let numberAddSubBigIntHelp = (x, y, isSub) => {
+  if (isSimpleNumber(y)) {
+    let yval = WasmI64.extendI32S(untagSimple(y))
+    let yBig = BI.makeWrappedInt64(yval)
+    let res = if (isSub) {
+      BI.sub(x, yBig)
+    } else {
+      BI.add(x, yBig)
+    }
+    Memory.decRef(yBig)
+    reducedBigInteger(res)
   } else {
-    let xtag = boxedNumberTag(x)
-    match (xtag) {
+    let yBoxedNumberTag = boxedNumberTag(y)
+    match (yBoxedNumberTag) {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
-        numberAddSubInt32Help(boxedInt32Number(x), y, isSub)
+        let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
+        let yBig = BI.makeWrappedInt64(yBoxedVal)
+        let res = if (isSub) {
+          BI.sub(x, yBig)
+        } else {
+          BI.add(x, yBig)
+        }
+        Memory.decRef(yBig)
+        reducedBigInteger(res)
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
-        numberAddSubInt64Help(boxedInt64Number(x), y, isSub)
+        let yBoxedVal = boxedInt64Number(y)
+        let yBig = BI.makeWrappedInt64(yBoxedVal)
+        let res = if (isSub) {
+          BI.sub(x, yBig)
+        } else {
+          BI.add(x, yBig)
+        }
+        Memory.decRef(yBig)
+        reducedBigInteger(res)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        let res = if (isSub) {
+          BI.sub(x, y)
+        } else {
+          BI.add(x, y)
+        }
+        reducedBigInteger(res)
       },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
-        numberAddSubRationalHelp(x, y, isSub)
+        let yNumerator = boxedRationalNumerator(y)
+        let yDenominator = boxedRationalDenominator(y)
+        let expandedXNumerator = BI.mul(x, yDenominator)
+        let result = if (isSub) BI.sub(expandedXNumerator, yNumerator)
+          else BI.add(expandedXNumerator, yNumerator)
+        Memory.decRef(expandedXNumerator)
+        let ret = reducedFractionBigInt(result, yDenominator)
+        Memory.decRef(result)
+        ret
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
-        numberAddSubFloat32Help(boxedFloat32Number(x), y, isSub)
+        let xval = BI.toFloat32(x)
+        let yBoxedVal = boxedFloat32Number(y)
+        let result = if (isSub) WasmF32.sub(xval, yBoxedVal)
+          else WasmF32.add(xval, yBoxedVal)
+        // TODO: (#304) this isn't safe enough
+        newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
-        numberAddSubFloat64Help(boxedFloat64Number(x), y, isSub)
+        let xval = BI.toFloat64(x)
+        let yBoxedVal = boxedFloat64Number(y)
+        let result = if (isSub) WasmF64.sub(xval, yBoxedVal)
+          else WasmF64.add(xval, yBoxedVal)
+        newFloat64(result)
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
-},
-numberAddSubRationalHelp = (x, y, isSub) => {
+}
+
+@unsafe
+let numberAddSubRationalHelp = (x, y, isSub) => {
+  let xNumerator = boxedRationalNumerator(x)
+  let xDenominator = boxedRationalDenominator(x)
   if (isSimpleNumber(y)) {
-    numberAddSubSimpleHelp(y, x, isSub)
+    let yval = untagSimple(y)
+    let yBig = BI.makeWrappedInt32(yval)
+    let expandedYNumerator = BI.mul(xDenominator, yBig)
+    let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+      else BI.add(xNumerator, expandedYNumerator)
+    Memory.decRef(expandedYNumerator)
+    Memory.decRef(yBig)
+    let ret = reducedFractionBigInt(result, xDenominator)
+    Memory.decRef(result)
+    ret
   } else {
     let ytag = boxedNumberTag(y)
     match (ytag) {
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         // The one case we don't delegate is rational +/- rational
-        let xNumerator = WasmI64.extendI32S(boxedRationalNumerator(x))
-        let xDenominator = WasmI64.extendI32S(boxedRationalDenominator(x))
-        let yNumerator = WasmI64.extendI32S(boxedRationalNumerator(y))
-        let yDenominator = WasmI64.extendI32S(boxedRationalDenominator(y))
-        // TODO: {#304) this could be written in a more overflow-proof way
-        if (WasmI64.eq(xDenominator, yDenominator)) {
-          let result = if (isSub) WasmI64.sub(xNumerator, yNumerator) else WasmI64.add(xNumerator, yNumerator)
-          reducedFraction64(result, xDenominator)
+        let xNumerator = boxedRationalNumerator(x)
+        let xDenominator = boxedRationalDenominator(x)
+        let yNumerator = boxedRationalNumerator(y)
+        let yDenominator = boxedRationalDenominator(y)
+        if (BI.eq(xDenominator, yDenominator)) {
+          let newNumerator = if (isSub) BI.sub(xNumerator, yNumerator)
+            else BI.add(xNumerator, yNumerator)
+          let ret = reducedFractionBigInt(newNumerator, xDenominator)
+          Memory.decRef(newNumerator)
+          ret
         } else {
-          let numerator1 = safeI64Multiply(xNumerator, yDenominator)
-          let numerator2 = safeI64Multiply(yNumerator, xDenominator)
-          let numerator = if (isSub) WasmI64.sub(numerator1, numerator2) else WasmI64.add(numerator1, numerator2)
-          let denominator = safeI64Multiply(xDenominator, yDenominator)
-          reducedFraction64(numerator, denominator)
+          let numerator1 = BI.mul(xNumerator, yDenominator)
+          let numerator2 = BI.mul(yNumerator, xDenominator)
+          let numerator = if (isSub) BI.sub(numerator1, numerator2)
+            else BI.add(numerator1, numerator2)
+          let denominator = BI.mul(xDenominator, yDenominator)
+          let ret = reducedFractionBigInt(numerator, denominator)
+          Memory.decRef(numerator1)
+          Memory.decRef(numerator2)
+          Memory.decRef(numerator)
+          ret
         }
-      }, t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
-        numberAddSubHelp(y, x, isSub)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        let yBig = BI.makeWrappedInt32(boxedInt32Number(y))
+        let expandedYNumerator = BI.mul(yBig, xDenominator)
+        Memory.decRef(yBig)
+        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+          else BI.add(xNumerator, expandedYNumerator)
+        let ret = reducedFractionBigInt(result, xDenominator)
+        Memory.decRef(expandedYNumerator)
+        Memory.decRef(result)
+        ret
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
-        numberAddSubHelp(y, x, isSub)
+        let yBig = BI.makeWrappedInt64(boxedInt64Number(y))
+        let expandedYNumerator = BI.mul(yBig, xDenominator)
+        Memory.decRef(yBig)
+        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+          else BI.add(xNumerator, expandedYNumerator)
+        let ret = reducedFractionBigInt(result, xDenominator)
+        Memory.decRef(expandedYNumerator)
+        Memory.decRef(result)
+        ret
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        let expandedYNumerator = BI.mul(xDenominator, y)
+        let result = if (isSub) BI.sub(xNumerator, expandedYNumerator)
+          else BI.add(xNumerator, expandedYNumerator)
+        Memory.decRef(expandedYNumerator)
+        let ret = reducedFractionBigInt(result, xDenominator)
+        Memory.decRef(result)
+        ret
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
-        numberAddSubHelp(y, x, isSub)
+        let xval = WasmF32.div(
+          BI.toFloat32(xNumerator),
+          BI.toFloat32(xDenominator)
+        )
+        let result = if (isSub) WasmF32.sub(xval, boxedFloat32Number(y))
+          else WasmF32.add(xval, boxedFloat32Number(y))
+        newFloat32(result)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
-        numberAddSubHelp(y, x, isSub)
+        let xnumfloat = BI.toFloat64(xNumerator)
+        let xdenfloat = BI.toFloat64(xDenominator)
+        let xval = WasmF64.div(xnumfloat, xdenfloat)
+        let yval = boxedFloat64Number(y)
+        let result = if (isSub) WasmF64.sub(xval, yval)
+          else WasmF64.add(xval, yval)
+        let ret = newFloat64(result)
+        ret
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
+let numberAddSubHelp = (x, y, isSub) => {
+  if (isSimpleNumber(x)) {
+    numberAddSubSimpleHelp(x, y, isSub)
+  } else {
+    let xtag = boxedNumberTag(x)
+    match (xtag) {
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        numberAddSubInt32Help(boxedInt32Number(x), y, isSub)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+        numberAddSubInt64Help(boxedInt64Number(x), y, isSub)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        numberAddSubBigIntHelp(x, y, isSub)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+        numberAddSubRationalHelp(x, y, isSub)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+        numberAddSubFloat32Help(boxedFloat32Number(x), y, isSub)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+        numberAddSubFloat64Help(boxedFloat64Number(x), y, isSub)
+      },
+      _ => {
+        throw UnknownNumberTag
+      },
+    }
+  }
+}
+
+@unsafe
 let numberAdd = (x, y) => {
   WasmI32.toGrain(numberAddSubHelp(x, y, false)): Number
 }
 
+@unsafe
 let numberSub = (x, y) => {
   WasmI32.toGrain(numberAddSubHelp(x, y, true)): Number
 }
@@ -840,12 +1247,32 @@ let numberSub = (x, y) => {
  * (same schema as equal())
  */
 
+@unsafe
+let safeI64Multiply = (x, y) => {
+  let prod = WasmI64.mul(x, y)
+  if (WasmI64.ne(x, 0N)) {
+    if (WasmI64.ne(WasmI64.divS(prod, x), y)) {
+      let xBig = BI.makeWrappedInt64(x)
+      let yBig = BI.makeWrappedInt64(y)
+      let result = BI.mul(xBig, yBig)
+      Memory.decRef(xBig)
+      Memory.decRef(yBig)
+      result
+    } else {
+      reducedInteger(prod)
+    }
+  } else {
+    reducedInteger(prod)
+  }
+}
+
+@unsafe
 let numberTimesDivideInt64Help = (xval, y, isDivide) => {
   if (isSimpleNumber(y)) {
     if (isDivide) {
       reducedFraction64(xval, WasmI64.extendI32S(untagSimple(y)))
     } else {
-      reducedInteger(safeI64Multiply(xval, WasmI64.extendI32S(untagSimple(y))))
+      safeI64Multiply(xval, WasmI64.extendI32S(untagSimple(y)))
     }
   } else {
     let yBoxedNumberTag = boxedNumberTag(y)
@@ -855,7 +1282,7 @@ let numberTimesDivideInt64Help = (xval, y, isDivide) => {
         if (isDivide) {
           reducedFraction64(xval, yBoxedVal)
         } else {
-          reducedInteger(safeI64Multiply(xval, yBoxedVal))
+          safeI64Multiply(xval, yBoxedVal)
         }
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
@@ -863,21 +1290,38 @@ let numberTimesDivideInt64Help = (xval, y, isDivide) => {
         if (isDivide) {
           reducedFraction64(xval, yBoxedVal)
         } else {
-          reducedInteger(safeI64Multiply(xval, yBoxedVal))
+          safeI64Multiply(xval, yBoxedVal)
+        }
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        let xBig = BI.makeWrappedInt64(xval)
+        let ret = if (isDivide) {
+          reducedFractionBigInt(xBig, y)
+        } else {
+          reducedBigInteger(BI.mul(xBig, y))
         }
+        Memory.decRef(xBig)
+        ret
       },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
-        let yNumerator = WasmI64.extendI32S(boxedRationalNumerator(y))
-        let yDenominator = WasmI64.extendI32S(boxedRationalDenominator(y))
-        if (isDivide) {
+        let yNumerator = boxedRationalNumerator(y)
+        let yDenominator = boxedRationalDenominator(y)
+        let xBig = BI.makeWrappedInt64(xval)
+        let ret = if (isDivide) {
           // x / (a / b) == (x * b) / a
-          let numerator = safeI64Multiply(xval, yDenominator)
-          reducedFraction64(numerator, yNumerator)
+          let numerator = BI.mul(xBig, yDenominator)
+          let ret = reducedFractionBigInt(numerator, yNumerator)
+          Memory.decRef(numerator)
+          ret
         } else {
           // x * (a / b) == (x * a) / b
-          let numerator = safeI64Multiply(xval, yNumerator)
-          reducedFraction64(numerator, yDenominator)
+          let numerator = BI.mul(xBig, yNumerator)
+          let ret = reducedFractionBigInt(numerator, yDenominator)
+          Memory.decRef(numerator)
+          ret
         }
+        Memory.decRef(xBig)
+        ret
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
         let xval = WasmF32.convertI64S(xval)
@@ -900,76 +1344,204 @@ let numberTimesDivideInt64Help = (xval, y, isDivide) => {
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
+    }
+  }
+}
+
+@unsafe
+let numberTimesDivideBigIntHelp = (x, y, isDivide) => {
+  if (isSimpleNumber(y)) {
+    let yBig = BI.makeWrappedInt32(untagSimple(y))
+    let ret = if (isDivide) {
+      reducedFractionBigInt(x, yBig)
+    } else {
+      reducedBigInteger(BI.mul(x, yBig))
+    }
+    Memory.decRef(yBig)
+    ret
+  } else {
+    let yBoxedNumberTag = boxedNumberTag(y)
+    match (yBoxedNumberTag) {
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        let yBoxedVal = WasmI64.extendI32S(boxedInt32Number(y))
+        let yBig = BI.makeWrappedInt64(yBoxedVal)
+        let ret = if (isDivide) {
+          reducedFractionBigInt(x, yBig)
+        } else {
+          reducedBigInteger(BI.mul(x, yBig))
+        }
+        Memory.decRef(yBig)
+        ret
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+        let yBoxedVal = boxedInt64Number(y)
+        let yBig = BI.makeWrappedInt64(yBoxedVal)
+        let ret = if (isDivide) {
+          reducedFractionBigInt(x, yBig)
+        } else {
+          reducedBigInteger(BI.mul(x, yBig))
+        }
+        Memory.decRef(yBig)
+        ret
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+        let yNumerator = boxedRationalNumerator(y)
+        let yDenominator = boxedRationalDenominator(y)
+        if (isDivide) {
+          // x / (a / b) == (x * b) / a
+          let numerator = BI.mul(x, yDenominator)
+          let ret = reducedFractionBigInt(numerator, yNumerator)
+          Memory.decRef(numerator)
+          ret
+        } else {
+          // x * (a / b) == (x * a) / b
+          let numerator = BI.mul(x, yNumerator)
+          let ret = reducedFractionBigInt(numerator, yDenominator)
+          Memory.decRef(numerator)
+          ret
+        }
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+        // We make the decision to always promote to f64 here, since
+        // we can only fit rather small bigints (<4 limbs) into an F32
+        let xval = BI.toFloat64(x)
+        let yBoxedVal = WasmF64.promoteF32(boxedFloat32Number(y))
+        // TODO: (#304) is this safe?
+        if (isDivide) {
+          newFloat64(WasmF64.div(xval, yBoxedVal))
+        } else {
+          newFloat64(WasmF64.mul(xval, yBoxedVal))
+        }
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+        let xval = BI.toFloat64(x)
+        let yBoxedVal = boxedFloat64Number(y)
+        if (isDivide) {
+          newFloat64(WasmF64.div(xval, yBoxedVal))
+        } else {
+          newFloat64(WasmF64.mul(xval, yBoxedVal))
+        }
+      },
+      _ => {
+        throw UnknownNumberTag
+      },
     }
   }
 }
 
+@unsafe
 let numberTimesDivideSimpleHelp = (x, y, isDivide) => {
   // PRECONDITION: x is a "simple" number (value tag is 0) and isNumber(y)
   let xval = untagSimple(x) // <- actual int value of x
   numberTimesDivideInt64Help(WasmI64.extendI32S(xval), y, isDivide)
 }
 
+@unsafe
 let numberTimesDivideInt32Help = (xval, y, isDivide) => {
   numberTimesDivideInt64Help(WasmI64.extendI32S(xval), y, isDivide)
 }
 
+@unsafe
 let numberTimesDivideRationalHelp = (x, y, isDivide) => {
   // Division isn't commutative, so we actually need to do the work
-  let xNumerator = WasmI64.extendI32S(boxedRationalNumerator(x))
-  let xDenominator = WasmI64.extendI32S(boxedRationalDenominator(x))
+  let xNumerator = boxedRationalNumerator(x)
+  let xDenominator = boxedRationalDenominator(x)
   if (isSimpleNumber(y)) {
-    if (isDivide) {
+    let yBig = BI.makeWrappedInt32(untagSimple(y))
+    let ret = if (isDivide) {
       // (a / b) / y == a / (b * y)
-      let denominator = safeI64Multiply(xDenominator, WasmI64.extendI32S(untagSimple(y)))
-      reducedFraction64(xNumerator, denominator)
+      let denominator = BI.mul(xDenominator, yBig)
+      let ret = reducedFractionBigInt(xNumerator, denominator)
+      Memory.decRef(denominator)
+      ret
     } else {
       // (a / b) * y == (a * y) / b
-      let numerator = safeI64Multiply(xNumerator, WasmI64.extendI32S(untagSimple(y)))
-      reducedFraction64(numerator, xDenominator)
+      let numerator = BI.mul(xNumerator, yBig)
+      let ret = reducedFractionBigInt(numerator, xDenominator)
+      Memory.decRef(numerator)
+      ret
     }
+    if (WasmI32.ne(yBig, ret)) {
+      Memory.decRef(yBig)
+      void
+    }
+    ret
   } else {
     let ytag = boxedNumberTag(y)
     match (ytag) {
       t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
         // Same idea as above
-        if (isDivide) {
+        let yBig = BI.makeWrappedInt32(boxedInt32Number(y))
+        let ret = if (isDivide) {
           // (a / b) / y == a / (b * y)
-          let denominator = safeI64Multiply(xDenominator, WasmI64.extendI32S(boxedInt32Number(y)))
-          reducedFraction64(xNumerator, denominator)
+          let denominator = BI.mul(xDenominator, yBig)
+          let ret = reducedFractionBigInt(xNumerator, denominator)
+          Memory.decRef(denominator)
+          ret
         } else {
           // (a / b) * y == (a * y) / b
-          let numerator = safeI64Multiply(xNumerator, WasmI64.extendI32S(boxedInt32Number(y)))
-          reducedFraction64(numerator, xDenominator)
+          let numerator = BI.mul(xNumerator, yBig)
+          let ret = reducedFractionBigInt(numerator, xDenominator)
+          Memory.decRef(numerator)
+          ret
         }
+        Memory.decRef(yBig)
+        ret
       },
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         // Same idea as above
+        let yBig = BI.makeWrappedInt64(boxedInt64Number(y))
+        let ret = if (isDivide) {
+          // (a / b) / y == a / (b * y)
+          let denominator = BI.mul(xDenominator, yBig)
+          let ret = reducedFractionBigInt(xNumerator, denominator)
+          Memory.decRef(denominator)
+          ret
+        } else {
+          // (a / b) * y == (a * y) / b
+          let numerator = BI.mul(xNumerator, yBig)
+          let ret = reducedFractionBigInt(numerator, xDenominator)
+          Memory.decRef(numerator)
+          ret
+        }
+        Memory.decRef(yBig)
+        ret
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
         if (isDivide) {
           // (a / b) / y == a / (b * y)
-          let denominator = safeI64Multiply(xDenominator, boxedInt64Number(y))
-          reducedFraction64(xNumerator, denominator)
+          let denominator = BI.mul(xDenominator, y)
+          let ret = reducedFractionBigInt(xNumerator, denominator)
+          Memory.decRef(denominator)
+          ret
         } else {
           // (a / b) * y == (a * y) / b
-          let numerator = safeI64Multiply(xNumerator, boxedInt64Number(y))
-          reducedFraction64(numerator, xDenominator)
+          let numerator = BI.mul(xNumerator, y)
+          let ret = reducedFractionBigInt(numerator, xDenominator)
+          Memory.decRef(numerator)
+          ret
         }
       },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
-        let xNumerator = WasmI64.extendI32S(boxedRationalNumerator(x))
-        let xDenominator = WasmI64.extendI32S(boxedRationalDenominator(x))
-        let yNumerator = WasmI64.extendI32S(boxedRationalNumerator(y))
-        let yDenominator = WasmI64.extendI32S(boxedRationalDenominator(y))
+        let xNumerator = boxedRationalNumerator(x)
+        let xDenominator = boxedRationalDenominator(x)
+        let yNumerator = boxedRationalNumerator(y)
+        let yDenominator = boxedRationalDenominator(y)
         // (a / b) * (c / d) == (a * c) / (b * d)
         // (a / b) / (c / d) == (a * d) / (b * c)
         // TODO: (#304) this could maybe be written in a more overflow-proof way
-        let numerator = if (isDivide) safeI64Multiply(xNumerator, yDenominator) else safeI64Multiply(xNumerator, yNumerator)
-        let denominator = if (isDivide) safeI64Multiply(xDenominator, yNumerator) else safeI64Multiply(xDenominator, yDenominator)
-        reducedFraction64(numerator, denominator)
+        let numerator = if (isDivide) BI.mul(xNumerator, yDenominator)
+          else BI.mul(xNumerator, yNumerator)
+        let denominator = if (isDivide) BI.mul(xDenominator, yNumerator)
+          else BI.mul(xDenominator, yDenominator)
+        reducedFractionBigInt(numerator, denominator)
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
-        let asFloat = WasmF32.div(WasmF32.convertI64S(xNumerator), WasmF32.convertI64S(xDenominator))
+        // TODO(#1190): We should probably use something more accurate if possible here
+        let asFloat = WasmF32.demoteF64(
+          WasmF64.div(BI.toFloat64(xNumerator), BI.toFloat64(xDenominator))
+        )
         if (isDivide) {
           newFloat32(WasmF32.div(asFloat, boxedFloat32Number(y)))
         } else {
@@ -977,7 +1549,11 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => {
         }
       },
       t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
-        let asFloat = WasmF64.div(WasmF64.convertI64S(xNumerator), WasmF64.convertI64S(xDenominator))
+        // TODO(#1190): We should probably use something more accurate if possible here
+        let asFloat = WasmF64.div(
+          BI.toFloat64(xNumerator),
+          BI.toFloat64(xDenominator)
+        )
         if (isDivide) {
           newFloat64(WasmF64.div(asFloat, boxedFloat64Number(y)))
         } else {
@@ -986,13 +1562,16 @@ let numberTimesDivideRationalHelp = (x, y, isDivide) => {
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 let numberTimesDivideFloat64Help = (x, y, isDivide) => {
-  let yAsFloat = coerceNumberToWasmF64(WasmI32.toGrain(y) : Number)
+  // incRef y to reuse it via WasmI32.toGrain
+  Memory.incRef(y)
+  let yAsFloat = coerceNumberToWasmF64(WasmI32.toGrain(y): Number)
   if (isDivide) {
     newFloat64(WasmF64.div(x, yAsFloat))
   } else {
@@ -1000,8 +1579,12 @@ let numberTimesDivideFloat64Help = (x, y, isDivide) => {
   }
 }
 
+@unsafe
 let numberTimesDivideFloat32Help = (x, y, isDivide) => {
-  if (isBoxedNumber(y) && WasmI32.eq(boxedNumberTag(y), Tags._GRAIN_INT64_BOXED_NUM_TAG)) {
+  if (
+    isBoxedNumber(y) &&
+    WasmI32.eq(boxedNumberTag(y), Tags._GRAIN_INT64_BOXED_NUM_TAG)
+  ) {
     // Special case: f32->f64 promotion
     if (isDivide) {
       newFloat64(WasmF64.div(WasmF64.promoteF32(x), boxedFloat64Number(y)))
@@ -1009,7 +1592,9 @@ let numberTimesDivideFloat32Help = (x, y, isDivide) => {
       newFloat64(WasmF64.mul(WasmF64.promoteF32(x), boxedFloat64Number(y)))
     }
   } else {
-    let yAsFloat = coerceNumberToWasmF32(WasmI32.toGrain(y) : Number)
+    // incRef y to reuse it via WasmI32.toGrain
+    Memory.incRef(y)
+    let yAsFloat = coerceNumberToWasmF32(WasmI32.toGrain(y): Number)
     if (isDivide) {
       newFloat32(WasmF32.div(x, yAsFloat))
     } else {
@@ -1018,6 +1603,7 @@ let numberTimesDivideFloat32Help = (x, y, isDivide) => {
   }
 }
 
+@unsafe
 let numberTimesDivideHelp = (x, y, isDivide) => {
   if (isSimpleNumber(x)) {
     numberTimesDivideSimpleHelp(x, y, isDivide)
@@ -1030,6 +1616,9 @@ let numberTimesDivideHelp = (x, y, isDivide) => {
       t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
         numberTimesDivideInt64Help(boxedInt64Number(x), y, isDivide)
       },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        numberTimesDivideBigIntHelp(x, y, isDivide)
+      },
       t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
         numberTimesDivideRationalHelp(x, y, isDivide)
       },
@@ -1041,15 +1630,17 @@ let numberTimesDivideHelp = (x, y, isDivide) => {
       },
       _ => {
         throw UnknownNumberTag
-      }
+      },
     }
   }
 }
 
+@unsafe
 let numberTimes = (x, y) => {
   WasmI32.toGrain(numberTimesDivideHelp(x, y, false)): Number
 }
 
+@unsafe
 let numberDivide = (x, y) => {
   WasmI32.toGrain(numberTimesDivideHelp(x, y, true)): Number
 }
@@ -1059,18 +1650,30 @@ let numberDivide = (x, y) => {
  * (same schema as equal())
  */
 
-let i64abs = (x) => if (WasmI64.geS(x, 0N)) x else WasmI64.sub(0N, x)
+@unsafe
+let i64abs = x => if (WasmI64.geS(x, 0N)) x else WasmI64.sub(0N, x)
 
+@unsafe
 let numberMod = (x, y) => {
-  let xval = coerceNumberToWasmI64(WasmI32.toGrain(x) : Number)
-  let yval = coerceNumberToWasmI64(WasmI32.toGrain(y) : Number)
+  // incRef x and y to reuse them via WasmI32.toGrain
+  Memory.incRef(x)
+  Memory.incRef(y)
+  let xval = coerceNumberToWasmI64(WasmI32.toGrain(x): Number)
+  let yval = coerceNumberToWasmI64(WasmI32.toGrain(y): Number)
   if (WasmI64.eqz(yval)) {
     throw Exception.ModuloByZero
   }
   // We implement true modulo
-  if (WasmI64.ltS(xval, 0N) && WasmI64.gtS(yval, 0N) || WasmI64.gtS(xval, 0N) && WasmI64.ltS(yval, 0N)) {
+  if (
+    WasmI64.ltS(xval, 0N) && WasmI64.gtS(yval, 0N) ||
+    WasmI64.gtS(xval, 0N) && WasmI64.ltS(yval, 0N)
+  ) {
     let modval = WasmI64.remS(i64abs(xval), i64abs(yval))
-    let result = if (WasmI64.ne(modval, 0N)) WasmI64.mul(WasmI64.sub(i64abs(yval), modval), (if (WasmI64.ltS(yval, 0N)) -1N else 1N)) else modval
+    let result = if (WasmI64.ne(modval, 0N))
+        WasmI64.mul(
+          WasmI64.sub(i64abs(yval), modval),
+          if (WasmI64.ltS(yval, 0N)) -1N else 1N
+        ) else modval
     reducedInteger(result)
   } else {
     reducedInteger(WasmI64.remS(xval, yval))
@@ -1082,384 +1685,532 @@ let numberMod = (x, y) => {
  * Coerce to float64 and then do comparisons
  * TODO: (#305) Could probably be made more efficient
  */
+
+@unsafe
+let cmpBigInt = (x: WasmI32, y: WasmI32) => {
+  if (isSimpleNumber(y)) {
+    BI.cmpI64(x, WasmI64.extendI32S(untagSimple(y)))
+  } else {
+    let yBoxedNumberTag = boxedNumberTag(y)
+    match (yBoxedNumberTag) {
+      t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => {
+        BI.cmpI64(x, WasmI64.extendI32S(boxedInt32Number(y)))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => {
+        BI.cmpI64(x, boxedInt64Number(y))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) => {
+        BI.cmp(x, y)
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => {
+        let tmp = BI.mul(x, boxedRationalDenominator(y))
+        let ret = BI.cmp(tmp, boxedRationalNumerator(y))
+        Memory.decRef(tmp)
+        ret
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
+        BI.cmpF32(x, boxedFloat32Number(y))
+      },
+      t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
+        BI.cmpF64(x, boxedFloat64Number(y))
+      },
+      _ => {
+        throw UnknownNumberTag
+      },
+    }
+  }
+}
+
 // TODO: (#305) is this safe? I think it's safe?
-export let rec (<) = (x: Number, y: Number) => {
-  let xval = coerceNumberToWasmF64(x)
-  let yval = coerceNumberToWasmF64(y)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  let ret = WasmF64.lt(xval, yval)
-  Memory.decRef(WasmI32.fromGrain((<)))
-  ret
+@unsafe
+export let (<) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  let yw32 = WasmI32.fromGrain(y)
+  if (isBigInt(xw32)) {
+    WasmI32.ltS(cmpBigInt(xw32, yw32), 0n)
+  } else if (isBigInt(yw32)) {
+    WasmI32.geS(cmpBigInt(yw32, xw32), 0n)
+  } else {
+    let xval = coerceNumberToWasmF64(x)
+    let yval = coerceNumberToWasmF64(y)
+    WasmF64.lt(xval, yval)
+  }
 }
 
-export let rec (>) = (x: Number, y: Number) => {
-  let xval = coerceNumberToWasmF64(x)
-  let yval = coerceNumberToWasmF64(y)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  let ret = WasmF64.gt(xval, yval)
-  Memory.decRef(WasmI32.fromGrain((>)))
-  ret
+@unsafe
+export let (>) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  let yw32 = WasmI32.fromGrain(y)
+  if (isBigInt(xw32)) {
+    WasmI32.gtS(cmpBigInt(xw32, yw32), 0n)
+  } else if (isBigInt(yw32)) {
+    WasmI32.leS(cmpBigInt(yw32, xw32), 0n)
+  } else {
+    let xval = coerceNumberToWasmF64(x)
+    let yval = coerceNumberToWasmF64(y)
+    WasmF64.gt(xval, yval)
+  }
 }
 
-export let rec (<=) = (x: Number, y: Number) => {
-  // Equality is finicky, so delegate
-  let xval = coerceNumberToWasmF64(x)
-  let yval = coerceNumberToWasmF64(y)
-  let ret = if (WasmF64.lt(xval, yval)) {
-    true
+@unsafe
+export let (<=) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  let yw32 = WasmI32.fromGrain(y)
+  if (isBigInt(xw32)) {
+    WasmI32.leS(cmpBigInt(xw32, yw32), 0n)
+  } else if (isBigInt(yw32)) {
+    WasmI32.geS(cmpBigInt(yw32, xw32), 0n)
   } else {
-    let x = WasmI32.fromGrain(x)
-    let y = WasmI32.fromGrain(y)
-    numberEqual(x, y)
+    // Equality is finicky, so delegate
+    let xval = coerceNumberToWasmF64(x)
+    let yval = coerceNumberToWasmF64(y)
+    if (WasmF64.lt(xval, yval)) {
+      true
+    } else {
+      let x = WasmI32.fromGrain(x)
+      let y = WasmI32.fromGrain(y)
+      numberEqual(x, y)
+    }
   }
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain((<=)))
-  ret
 }
 
-export let rec (>=) = (x: Number, y: Number) => {
-  // Equality is finicky, so delegate
-  let xval = coerceNumberToWasmF64(x)
-  let yval = coerceNumberToWasmF64(y)
-  let ret = if (WasmF64.gt(xval, yval)) {
-    true
+@unsafe
+export let (>=) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  let yw32 = WasmI32.fromGrain(y)
+  if (isBigInt(xw32)) {
+    WasmI32.leS(cmpBigInt(xw32, yw32), 0n)
+  } else if (isBigInt(yw32)) {
+    WasmI32.geS(cmpBigInt(yw32, xw32), 0n)
   } else {
-    let x = WasmI32.fromGrain(x)
-    let y = WasmI32.fromGrain(y)
-    numberEqual(x, y)
+    // Equality is finicky, so delegate
+    let xval = coerceNumberToWasmF64(x)
+    let yval = coerceNumberToWasmF64(y)
+    if (WasmF64.gt(xval, yval)) {
+      true
+    } else {
+      let x = WasmI32.fromGrain(x)
+      let y = WasmI32.fromGrain(y)
+      numberEqual(x, y)
+    }
   }
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain((>=)))
-  ret
 }
 
 /*
  * ===== EQUAL =====
  */
 
-export let rec numberEq = (x: Number, y: Number) => {
+@unsafe
+export let numberEq = (x: Number, y: Number) => {
   let x = WasmI32.fromGrain(x)
   let y = WasmI32.fromGrain(y)
-  let ret = numberEqual(x, y)
-  Memory.decRef(x)
-  Memory.decRef(y)
-  Memory.decRef(WasmI32.fromGrain(numberEq))
-  ret
+  numberEqual(x, y)
 }
 
 /*
  * ===== LOGICAL OPERATIONS =====
- * Only valid for int-like numbers. Coerce to i64 and do operations
+ * Only valid for int-like numbers. Coerce to i64/bigInt and do operations
  */
 // TODO: (#306) Semantics around when things should stay i32/i64
 
-export let rec lnot = (x: Number) => {
-  let xval = coerceNumberToWasmI64(x)
-  let ret = WasmI32.toGrain(reducedInteger(i64not(xval))): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(lnot))
-  ret
+@unsafe
+export let lnot = (x: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  if (isBigInt(xw32)) {
+    WasmI32.toGrain(reducedBigInteger(BI.bitwiseNot(xw32))): Number
+  } else {
+    let xval = coerceNumberToWasmI64(x)
+    WasmI32.toGrain(reducedInteger(i64not(xval))): Number
+  }
 }
 
-export let rec (<<) = (x: Number, y: Number) => {
-  let xval = coerceNumberToWasmI64(x)
-  let yval = coerceNumberToWasmI64(y)
-  let ret = WasmI32.toGrain(reducedInteger(WasmI64.shl(xval, yval))): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain((<<)))
-  ret
+@unsafe
+export let (<<) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  if (isBigInt(xw32)) {
+    let yval = coerceNumberToWasmI32(y)
+    WasmI32.toGrain(reducedBigInteger(BI.shl(xw32, yval))): Number
+  } else {
+    let xval = coerceNumberToWasmI64(x)
+    let yval = coerceNumberToWasmI64(y)
+    WasmI32.toGrain(reducedInteger(WasmI64.shl(xval, yval))): Number
+  }
 }
 
-export let rec (>>>) = (x: Number, y: Number) => {
-  let xval = coerceNumberToWasmI64(x)
-  let yval = coerceNumberToWasmI64(y)
-  let ret = WasmI32.toGrain(reducedInteger(WasmI64.shrU(xval, yval))): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain((>>>)))
-  ret
+@unsafe
+export let (>>>) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  if (isBigInt(xw32)) {
+    let yval = coerceNumberToWasmI32(y)
+    // [NOTE]: For BigInts, shrU is the same as shrS because there
+    //         are an *infinite* number of leading ones
+    WasmI32.toGrain(reducedBigInteger(BI.shrS(xw32, yval))): Number
+  } else {
+    let xval = coerceNumberToWasmI64(x)
+    let yval = coerceNumberToWasmI64(y)
+    WasmI32.toGrain(reducedInteger(WasmI64.shrU(xval, yval))): Number
+  }
 }
 
-export let rec (&) = (x: Number, y: Number) => {
-  let xval = coerceNumberToWasmI64(x)
-  let yval = coerceNumberToWasmI64(y)
-  let ret = WasmI32.toGrain(reducedInteger(WasmI64.and(xval, yval))): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain((&)))
-  ret
+@unsafe
+export let (&) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  let yw32 = WasmI32.fromGrain(y)
+  if (isBigInt(xw32) || isBigInt(yw32)) {
+    let xval = coerceNumberToBigInt(x)
+    let yval = coerceNumberToBigInt(y)
+    let ret = WasmI32.toGrain(
+      reducedBigInteger(BI.bitwiseAnd(xval, yval))
+    ): Number
+    if (!WasmI32.eq(xw32, xval)) {
+      Memory.decRef(xval)
+      void
+    }
+    if (!WasmI32.eq(yw32, yval)) {
+      Memory.decRef(yval)
+      void
+    }
+    ret
+  } else {
+    let xval = coerceNumberToWasmI64(x)
+    let yval = coerceNumberToWasmI64(y)
+    WasmI32.toGrain(reducedInteger(WasmI64.and(xval, yval))): Number
+  }
 }
 
-export let rec (|) = (x: Number, y: Number) => {
-  let xval = coerceNumberToWasmI64(x)
-  let yval = coerceNumberToWasmI64(y)
-  let ret = WasmI32.toGrain(reducedInteger(WasmI64.or(xval, yval))): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain((|)))
-  ret
+@unsafe
+export let (|) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  let yw32 = WasmI32.fromGrain(y)
+  if (isBigInt(xw32) || isBigInt(yw32)) {
+    let xval = coerceNumberToBigInt(x)
+    let yval = coerceNumberToBigInt(y)
+    let ret = WasmI32.toGrain(
+      reducedBigInteger(BI.bitwiseOr(xval, yval))
+    ): Number
+    if (!WasmI32.eq(xw32, xval)) {
+      Memory.decRef(xval)
+      void
+    }
+    if (!WasmI32.eq(yw32, yval)) {
+      Memory.decRef(yval)
+      void
+    }
+    ret
+  } else {
+    let xval = coerceNumberToWasmI64(x)
+    let yval = coerceNumberToWasmI64(y)
+    WasmI32.toGrain(reducedInteger(WasmI64.or(xval, yval))): Number
+  }
 }
 
-export let rec (^) = (x: Number, y: Number) => {
-  let xval = coerceNumberToWasmI64(x)
-  let yval = coerceNumberToWasmI64(y)
-  let ret = WasmI32.toGrain(reducedInteger(WasmI64.xor(xval, yval))): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain((^)))
-  ret
+@unsafe
+export let (^) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  let yw32 = WasmI32.fromGrain(y)
+  if (isBigInt(xw32) || isBigInt(yw32)) {
+    let xval = coerceNumberToBigInt(x)
+    let yval = coerceNumberToBigInt(y)
+    let ret = WasmI32.toGrain(
+      reducedBigInteger(BI.bitwiseXor(xval, yval))
+    ): Number
+    if (!WasmI32.eq(xw32, xval)) {
+      Memory.decRef(xval)
+      void
+    }
+    if (!WasmI32.eq(yw32, yval)) {
+      Memory.decRef(yval)
+      void
+    }
+    ret
+  } else {
+    let xval = coerceNumberToWasmI64(x)
+    let yval = coerceNumberToWasmI64(y)
+    WasmI32.toGrain(reducedInteger(WasmI64.xor(xval, yval))): Number
+  }
 }
 
-export let rec (>>) = (x: Number, y: Number) => {
-  let xval = coerceNumberToWasmI64(x)
-  let yval = coerceNumberToWasmI64(y)
-  let ret = WasmI32.toGrain(reducedInteger(WasmI64.shrS(xval, yval))): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain((>>)))
-  ret
+@unsafe
+export let (>>) = (x: Number, y: Number) => {
+  let xw32 = WasmI32.fromGrain(x)
+  if (isBigInt(xw32)) {
+    let yval = coerceNumberToWasmI32(y)
+    // [NOTE]: For BigInts, shrU is the same as shrS because there
+    //         are an *infinite* number of leading ones
+    WasmI32.toGrain(reducedBigInteger(BI.shrS(xw32, yval))): Number
+  } else {
+    let xval = coerceNumberToWasmI64(x)
+    let yval = coerceNumberToWasmI64(y)
+    WasmI32.toGrain(reducedInteger(WasmI64.shrS(xval, yval))): Number
+  }
 }
 
-
 /// USER-EXPOSED COERCION FUNCTIONS
 //
 // [NOTE]: Coercion is a *conservative* process! For example, even if a float is 1.0,
 //         we will fail if attempting to coerce to an int!
 
+@unsafe
 export let rec coerceNumberToInt32 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
-  let result = if (!isSimpleNumber(x) && WasmI32.eq(boxedNumberTag(x), Tags._GRAIN_INT32_BOXED_NUM_TAG)) {
-    // avoid extra malloc
+  let result = if (
+    !isSimpleNumber(x) &&
+    WasmI32.eq(boxedNumberTag(x), Tags._GRAIN_INT32_BOXED_NUM_TAG)
+  ) {
+    // avoid extra malloc and prevent x from being freed
+    Memory.incRef(x)
     x
   } else {
+    // incRef x to reuse it via WasmI32.toGrain
+    Memory.incRef(x)
     // can possibly fail
-    newInt32(coerceNumberToWasmI32(WasmI32.toGrain(x) : Number))
-  }
-  let ret = WasmI32.toGrain(result): Int32
-  if (WasmI32.fromGrain(ret) != WasmI32.fromGrain(x)) {
-    Memory.decRef(WasmI32.fromGrain(x))
-    void
+    newInt32(coerceNumberToWasmI32(WasmI32.toGrain(x): Number))
   }
-  Memory.decRef(WasmI32.fromGrain(coerceNumberToInt32))
-  ret
+  WasmI32.toGrain(result): Int32
 }
 
+@unsafe
 export let rec coerceNumberToInt64 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
-  let result = if (!isSimpleNumber(x) && WasmI32.eq(boxedNumberTag(x), Tags._GRAIN_INT64_BOXED_NUM_TAG)) {
-    // avoid extra malloc
+  let result = if (
+    !isSimpleNumber(x) &&
+    WasmI32.eq(boxedNumberTag(x), Tags._GRAIN_INT64_BOXED_NUM_TAG)
+  ) {
+    // avoid extra malloc and prevent x from being freed
+    Memory.incRef(x)
     x
   } else {
-    newInt64(coerceNumberToWasmI64(WasmI32.toGrain(x) : Number))
+    // incRef x to reuse it via WasmI32.toGrain
+    Memory.incRef(x)
+    newInt64(coerceNumberToWasmI64(WasmI32.toGrain(x): Number))
   }
-  let ret = WasmI32.toGrain(result): Int64
-  if (WasmI32.fromGrain(ret) != WasmI32.fromGrain(x)) {
-    Memory.decRef(WasmI32.fromGrain(x))
-    void
+  WasmI32.toGrain(result): Int64
+}
+
+@unsafe
+export let rec coerceNumberToBigInt = (x: Number) => {
+  let x = WasmI32.fromGrain(x)
+  let result = if (isBigInt(x)) {
+    // avoid extra malloc and prevent x from being freed
+    Memory.incRef(x)
+    x
+  } else {
+    // incRef x to reuse it via WasmI32.toGrain
+    Memory.incRef(x)
+    BI.makeWrappedInt64(coerceNumberToWasmI64(WasmI32.toGrain(x): Number))
   }
-  Memory.decRef(WasmI32.fromGrain(coerceNumberToInt64))
-  ret
+  WasmI32.toGrain(result): BigInt
 }
 
-export let rec coerceNumberToRational = (x: Number) => {
+@unsafe
+export let coerceNumberToRational = (x: Number) => {
   let x = WasmI32.fromGrain(x)
   let result = if (isSimpleNumber(x)) {
-    newRational(untagSimple(x), 1n)
+    newRational(BI.makeWrappedInt32(untagSimple(x)), BI.makeWrappedInt32(1n))
   } else {
     let tag = boxedNumberTag(x)
     if (WasmI32.eq(tag, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG)) {
+      // avoid extra malloc and prevent x from being freed
+      Memory.incRef(x)
       x
     } else if (WasmI32.eq(tag, Tags._GRAIN_INT32_BOXED_NUM_TAG)) {
-      newRational(boxedInt32Number(x), 1n)
+      newRational(
+        BI.makeWrappedInt32(boxedInt32Number(x)),
+        BI.makeWrappedInt32(1n)
+      )
     } else if (WasmI32.eq(tag, Tags._GRAIN_INT64_BOXED_NUM_TAG)) {
-      newRational(coerceNumberToWasmI32(WasmI32.toGrain(x) : Number), 1n)
+      // incRef x to reuse it via WasmI32.toGrain
+      Memory.incRef(x)
+      newRational(
+        BI.makeWrappedInt32(coerceNumberToWasmI32(WasmI32.toGrain(x): Number)),
+        BI.makeWrappedInt32(1n)
+      )
     } else {
       throw Exception.NumberNotRational
     }
   }
-  let ret = WasmI32.toGrain(result): Rational
-  if (WasmI32.fromGrain(ret) != WasmI32.fromGrain(x)) {
-    Memory.decRef(WasmI32.fromGrain(x))
-    void
-  }
-  Memory.decRef(WasmI32.fromGrain(coerceNumberToRational))
-  ret
+  WasmI32.toGrain(result): Rational
 }
 
-export let rec coerceNumberToFloat32 = (x: Number) => {
+@unsafe
+export let coerceNumberToFloat32 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
-  let result = if (!isSimpleNumber(x) && WasmI32.eq(boxedNumberTag(x), Tags._GRAIN_FLOAT32_BOXED_NUM_TAG)) {
-    // avoid extra malloc
+  let result = if (
+    !isSimpleNumber(x) &&
+    WasmI32.eq(boxedNumberTag(x), Tags._GRAIN_FLOAT32_BOXED_NUM_TAG)
+  ) {
+    // avoid extra malloc and prevent x from being freed
+    Memory.incRef(x)
     x
   } else {
-    newFloat32(coerceNumberToWasmF32(WasmI32.toGrain(x) : Number))
+    // incRef x to reuse it via WasmI32.toGrain
+    Memory.incRef(x)
+    newFloat32(coerceNumberToWasmF32(WasmI32.toGrain(x): Number))
   }
-  let ret = WasmI32.toGrain(result): Float32
-  if (WasmI32.fromGrain(ret) != WasmI32.fromGrain(x)) {
-    Memory.decRef(WasmI32.fromGrain(x))
-    void
-  }
-  Memory.decRef(WasmI32.fromGrain(coerceNumberToFloat32))
-  ret
+  WasmI32.toGrain(result): Float32
 }
 
-export let rec coerceNumberToFloat64 = (x: Number) => {
+@unsafe
+export let coerceNumberToFloat64 = (x: Number) => {
   let x = WasmI32.fromGrain(x)
-  let result = if (!isSimpleNumber(x) && WasmI32.eq(boxedNumberTag(x), Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)) {
-    // avoid extra malloc
+  let result = if (
+    !isSimpleNumber(x) &&
+    WasmI32.eq(boxedNumberTag(x), Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)
+  ) {
+    // avoid extra malloc and prevent x from being freed
+    Memory.incRef(x)
     x
   } else {
-    newFloat64(coerceNumberToWasmF64(WasmI32.toGrain(x) : Number))
+    // incRef x to reuse it via WasmI32.toGrain
+    Memory.incRef(x)
+    newFloat64(coerceNumberToWasmF64(WasmI32.toGrain(x): Number))
   }
-  let ret = WasmI32.toGrain(result): Float64
-  if (WasmI32.fromGrain(ret) != WasmI32.fromGrain(x)) {
-    Memory.decRef(WasmI32.fromGrain(x))
-    void
-  }
-  Memory.decRef(WasmI32.fromGrain(coerceNumberToFloat64))
-  ret
+  WasmI32.toGrain(result): Float64
 }
 
-// These coerceXX functions don't need Memory.decRef calls since they simply return their argument
-export let rec coerceInt32ToNumber = (x: Int32) => {
-  let ret = WasmI32.toGrain(WasmI32.fromGrain(x)): Number
-  Memory.decRef(WasmI32.fromGrain(coerceInt32ToNumber))
-  ret
+@unsafe
+export let coerceInt32ToNumber = (x: Int32) => {
+  let x = WasmI32.fromGrain(x)
+  // incRef x to reuse it via WasmI32.toGrain
+  Memory.incRef(x)
+  WasmI32.toGrain(x): Number
 }
 
-export let rec coerceInt64ToNumber = (x: Int64) => {
-  let ret = WasmI32.toGrain(WasmI32.fromGrain(x)): Number
-  Memory.decRef(WasmI32.fromGrain(coerceInt64ToNumber))
-  ret
+@unsafe
+export let coerceInt64ToNumber = (x: Int64) => {
+  let x = WasmI32.fromGrain(x)
+  // incRef x to reuse it via WasmI32.toGrain
+  Memory.incRef(x)
+  WasmI32.toGrain(x): Number
 }
 
-export let rec coerceRationalToNumber = (x: Rational) => {
-  let ret = WasmI32.toGrain(WasmI32.fromGrain(x)): Number
-  Memory.decRef(WasmI32.fromGrain(coerceRationalToNumber))
-  ret
+@unsafe
+export let coerceBigIntToNumber = (x: BigInt) => {
+  let x = WasmI32.fromGrain(x)
+  // incRef x to reuse it via WasmI32.toGrain
+  Memory.incRef(x)
+  WasmI32.toGrain(x): Number
 }
 
-export let rec coerceFloat32ToNumber = (x: Float32) => {
-  let ret = WasmI32.toGrain(WasmI32.fromGrain(x)): Number
-  Memory.decRef(WasmI32.fromGrain(coerceFloat32ToNumber))
-  ret
+@unsafe
+export let coerceRationalToNumber = (x: Rational) => {
+  let x = WasmI32.fromGrain(x)
+  // incRef x to reuse it via WasmI32.toGrain
+  Memory.incRef(x)
+  WasmI32.toGrain(x): Number
 }
 
-export let rec coerceFloat64ToNumber = (x: Float64) => {
-  let ret = WasmI32.toGrain(WasmI32.fromGrain(x)): Number
-  Memory.decRef(WasmI32.fromGrain(coerceFloat64ToNumber))
-  ret
+@unsafe
+export let coerceFloat32ToNumber = (x: Float32) => {
+  let x = WasmI32.fromGrain(x)
+  // incRef x to reuse it via WasmI32.toGrain
+  Memory.incRef(x)
+  WasmI32.toGrain(x): Number
+}
+
+@unsafe
+export let coerceFloat64ToNumber = (x: Float64) => {
+  let x = WasmI32.fromGrain(x)
+  // incRef x to reuse it via WasmI32.toGrain
+  Memory.incRef(x)
+  WasmI32.toGrain(x): Number
 }
 
 /// USER-EXPOSED CONVERSION FUNCTIONS
 
-export let rec convertExactToInexact = (x: Number) => {
-  let ret = x
-  Memory.decRef(WasmI32.fromGrain(convertExactToInexact))
-  ret
+@unsafe
+export let convertExactToInexact = (x: Number) => {
+  x
 }
 
-let convertInexactToExactHelp = (x) => {
+@unsafe
+let convertInexactToExactHelp = x => {
   if (isSimpleNumber(x)) {
     x
   } else {
     let tag = boxedNumberTag(x)
-    if (WasmI32.eq(tag, Tags._GRAIN_INT32_BOXED_NUM_TAG) || WasmI32.eq(tag, Tags._GRAIN_INT64_BOXED_NUM_TAG) || WasmI32.eq(tag, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG)) {
+    if (
+      WasmI32.eq(tag, Tags._GRAIN_INT32_BOXED_NUM_TAG) ||
+      WasmI32.eq(tag, Tags._GRAIN_INT64_BOXED_NUM_TAG) ||
+      WasmI32.eq(tag, Tags._GRAIN_BIGINT_BOXED_NUM_TAG) ||
+      WasmI32.eq(tag, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG)
+    ) {
+      Memory.incRef(x)
       x
     } else {
       match (tag) {
-        t when WasmI32.eq(t, Tags._GRAIN_INT32_BOXED_NUM_TAG) => x,
-        t when WasmI32.eq(t, Tags._GRAIN_INT64_BOXED_NUM_TAG) => x,
-        t when WasmI32.eq(t, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) => x,
         t when WasmI32.eq(t, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG) => {
-          reducedInteger(WasmI64.truncF32S(WasmF32.nearest(boxedFloat32Number(x))))
+          // TODO(#1191): Investigate if BigInt is more accurate
+          reducedInteger(
+            WasmI64.truncF32S(WasmF32.nearest(boxedFloat32Number(x)))
+          )
         },
         t when WasmI32.eq(t, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG) => {
-          reducedInteger(WasmI64.truncF64S(WasmF64.nearest(boxedFloat64Number(x))))
+          // TODO(#1191): Investigate if BigInt is more accurate
+          reducedInteger(
+            WasmI64.truncF64S(WasmF64.nearest(boxedFloat64Number(x)))
+          )
         },
         _ => {
           throw UnknownNumberTag
-        }
+        },
       }
     }
   }
 }
 
-export let rec convertInexactToExact = (x: Number) => {
-  let ret = WasmI32.toGrain(convertInexactToExactHelp(WasmI32.fromGrain(x))): Number
-  if (WasmI32.fromGrain(ret) != WasmI32.fromGrain(x)) {
-    Memory.decRef(WasmI32.fromGrain(x))
-    void
-  }
-  Memory.decRef(WasmI32.fromGrain(convertInexactToExact))
-  ret
+@unsafe
+export let convertInexactToExact = (x: Number) => {
+  WasmI32.toGrain(convertInexactToExactHelp(WasmI32.fromGrain(x))): Number
 }
 
-export let rec (+) = (x: Number, y: Number) => {
+@unsafe
+export let (+) = (x: Number, y: Number) => {
   let x = WasmI32.fromGrain(x)
   let y = WasmI32.fromGrain(y)
-  let ret = numberAdd(x, y)
-  Memory.decRef(x)
-  Memory.decRef(y)
-  Memory.decRef(WasmI32.fromGrain((+)))
-  ret
+  numberAdd(x, y)
 }
 
-export let rec (-) = (x: Number, y: Number) => {
+@unsafe
+export let (-) = (x: Number, y: Number) => {
   let x = WasmI32.fromGrain(x)
   let y = WasmI32.fromGrain(y)
-  let ret = numberSub(x, y)
-  Memory.decRef(x)
-  Memory.decRef(y)
-  Memory.decRef(WasmI32.fromGrain((-)))
-  ret
+  numberSub(x, y)
 }
 
-export let rec (*) = (x: Number, y: Number) => {
+@unsafe
+export let (*) = (x: Number, y: Number) => {
   let x = WasmI32.fromGrain(x)
   let y = WasmI32.fromGrain(y)
-  let ret = numberTimes(x, y)
-  Memory.decRef(x)
-  Memory.decRef(y)
-  Memory.decRef(WasmI32.fromGrain((*)))
-  ret
+  numberTimes(x, y)
 }
 
-export let rec (/) = (x: Number, y: Number) => {
+@unsafe
+export let (/) = (x: Number, y: Number) => {
   let x = WasmI32.fromGrain(x)
   let y = WasmI32.fromGrain(y)
-  let ret = numberDivide(x, y)
-  Memory.decRef(x)
-  Memory.decRef(y)
-  Memory.decRef(WasmI32.fromGrain((/)))
-  ret
+  numberDivide(x, y)
 }
 
-export let rec (%) = (x: Number, y: Number) => {
+@unsafe
+export let (%) = (x: Number, y: Number) => {
   let x = WasmI32.fromGrain(x)
   let y = WasmI32.fromGrain(y)
-  let ret = WasmI32.toGrain(numberMod(x, y)): Number
-  Memory.decRef(x)
-  Memory.decRef(y)
-  Memory.decRef(WasmI32.fromGrain((%)))
-  ret
+  WasmI32.toGrain(numberMod(x, y)): Number
 }
 
 // inc/dec
 
-export let incr = (x) => {
-  Memory.incRef(WasmI32.fromGrain((+)))
-  // skip incRef on x (to pass through)
+export let incr = x => {
   x + 1
 }
 
-export let decr = (x) => {
-  Memory.incRef(WasmI32.fromGrain((-)))
-  // skip incRef on x (to pass through)
+export let decr = x => {
   x - 1
 }
+
+@unsafe
+export let isBigInt = x => {
+  let x = WasmI32.fromGrain(x)
+  isBigInt(x)
+}