@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-IR74FJHU.js

@@ -0,0 +1,2332 @@
+'use strict';
+
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+var chunkJGBCIKJV_js = require('./chunk-JGBCIKJV.js');
+
+// src/game/kernel/fmath.ts
+var fmath_exports = {};
+chunkJGBCIKJV_js.__export(fmath_exports, {
+  FMATH_CONSTANTS: () => FMATH_CONSTANTS,
+  acos: () => acos,
+  asin: () => asin,
+  atan: () => atan,
+  atan2: () => atan2,
+  cos: () => cos,
+  exp: () => exp,
+  exp2: () => exp2,
+  f32Bits: () => f32Bits,
+  f32From: () => f32From,
+  log: () => log,
+  log2: () => log2,
+  pow: () => pow,
+  sin: () => sin,
+  tan: () => tan
+});
+var f64 = new Float64Array(1), w64 = new Uint32Array(f64.buffer), f32 = new Float32Array(1), w32 = new Uint32Array(f32.buffer), fround = Math.fround;
+function f32Bits(x) {
+  return f32[0] = x, w32[0];
+}
+function f32From(bits) {
+  return w32[0] = bits >>> 0, f32[0];
+}
+function f64From(hi, lo) {
+  return w64[0] = lo >>> 0, w64[1] = hi >>> 0, f64[0];
+}
+function lowWord(x) {
+  return f64[0] = x, w64[0];
+}
+function d(hex) {
+  return f64From(Number.parseInt(hex.slice(0, 8), 16), Number.parseInt(hex.slice(8), 16));
+}
+var EXP2_TABLE = [
+  "3ff0000000000000",
+  "3fefd9b0d3158574",
+  "3fefb5586cf9890f",
+  "3fef9301d0125b51",
+  "3fef72b83c7d517b",
+  "3fef54873168b9aa",
+  "3fef387a6e756238",
+  "3fef1e9df51fdee1",
+  "3fef06fe0a31b715",
+  "3feef1a7373aa9cb",
+  "3feedea64c123422",
+  "3feece086061892d",
+  "3feebfdad5362a27",
+  "3feeb42b569d4f82",
+  "3feeab07dd485429",
+  "3feea47eb03a5585",
+  "3feea09e667f3bcd",
+  "3fee9f75e8ec5f74",
+  "3feea11473eb0187",
+  "3feea589994cce13",
+  "3feeace5422aa0db",
+  "3feeb737b0cdc5e5",
+  "3feec49182a3f090",
+  "3feed503b23e255d",
+  "3feee89f995ad3ad",
+  "3feeff76f2fb5e47",
+  "3fef199bdd85529c",
+  "3fef3720dcef9069",
+  "3fef5818dcfba487",
+  "3fef7c97337b9b5f",
+  "3fefa4afa2a490da",
+  "3fefd0765b6e4540"
+], EXP2_HI = EXP2_TABLE.map((h) => Number.parseInt(h.slice(0, 8), 16)), EXP2_LO = EXP2_TABLE.map((h) => Number.parseInt(h.slice(8), 16)), EXP2_POLY = [d("3fac6af84b912394"), d("3fcebfce50fac4f3"), d("3fe62e42ff0c52d6")], EXP_POLY = [d("3ebc6af84b912394"), d("3f2ebfce50fac4f3"), d("3f962e42ff0c52d6")], INV_LN2_N = d("40471547652b82fe"), SHIFT = d("4338000000000000"), SHIFT_SCALED = d("42e8000000000000"), EXP_LOW = -104, EXP_HIGH = 89, EXP2_LOW = -151, EXP2_HIGH = 129, INV_C = [
+  "3ff661ec79f8f3be",
+  "3ff571ed4aaf883d",
+  "3ff49539f0f010b0",
+  "3ff3c995b0b80385",
+  "3ff30d190c8864a5",
+  "3ff25e227b0b8ea0",
+  "3ff1bb4a4a1a343f",
+  "3ff12358f08ae5ba",
+  "3ff0953f419900a7",
+  "3ff0000000000000",
+  "3fee608cfd9a47ac",
+  "3feca4b31f026aa0",
+  "3feb2036576afce6",
+  "3fe9c2d163a1aa2d",
+  "3fe886e6037841ed",
+  "3fe767dcf5534862"
+].map(d), LOG_C = [
+  "bfd57bf7808caade",
+  "bfd2bef0a7c06ddb",
+  "bfd01eae7f513a67",
+  "bfcb31d8a68224e9",
+  "bfc6574f0ac07758",
+  "bfc1aa2bc79c8100",
+  "bfba4e76ce8c0e5e",
+  "bfb1973c5a611ccc",
+  "bfa252f438e10c1e",
+  "0000000000000000",
+  "3faaa5aa5df25984",
+  "3fbc5e53aa362eb4",
+  "3fc526e57720db08",
+  "3fcbc2860d224770",
+  "3fd1058bc8a07ee1",
+  "3fd4043057b6ee09"
+].map(d), LOG2_C = [
+  "bfdefec65b963019",
+  "bfdb0b6832d4fca4",
+  "bfd7418b0a1fb77b",
+  "bfd39de91a6dcf7b",
+  "bfd01d9bf3f2b631",
+  "bfc97c1d1b3b7af0",
+  "bfc2f9e393af3c9f",
+  "bfb960cbbf788d5c",
+  "bfaa6f9db6475fce",
+  "0000000000000000",
+  "3fb338ca9f24f53d",
+  "3fc476a9543891ba",
+  "3fce840b4ac4e4d2",
+  "3fd40645f0c6651c",
+  "3fd88e9c2c1b9ff8",
+  "3fdce0a44eb17bcc"
+].map(d), LN2 = d("3fe62e42fefa39ef"), LOG_POLY = ["bfd00ea348b88334", "3fd5575b0be00b6a", "bfdffffef20a4123"].map(d), LOG2_POLY = ["bfd712b6f70a7e4d", "3fdecabf496832e0", "bfe715479ffae3de", "3ff715475f35c8b8"].map(d), POW_POLY = ["3fd27616c9496e0b", "bfd71969a075c67a", "3fdec70a6ca7badd", "bfe7154748bef6c8", "3ff71547652ab82b"].map(d), POW_SIGN_BIAS = 65536, POW_OVERFLOW = d("405fffffffd1d571"), POW_SATURATE = d("405fffffffa3aae2"), POW_UNDERFLOW = -150, LOG_OFF = 1060306944, SUBNORMAL_SCALE = 8388608, SUBNORMAL_BIAS = 23 << 23, MIN_NORMAL = 8388608, INFINITY_BITS = 2139095040, ONE_BITS = 1065353216, SIGN = 2147483648, ABS = 2147483647, EXPONENT_MASK = 4286578688, F32_MAX = f32From(2139095039), HPI_INV = d("41645f306dc9c883"), HPI = d("3ff921fb54442d18"), PI63 = d("3c1921fb54442d18"), COS_C1 = d("bfdffffffd0c621c"), COS_C2 = d("3fa55553e1068f19"), COS_C3 = d("bf56c087e89a359d"), COS_C4 = d("3ef99343027bf8c3"), SIN_S1 = d("bfc555545995a603"), SIN_S2 = d("3f81107605230bc4"), SIN_S3 = d("bf2994eb3774cf24"), QUADRANT_SIGN = [1, -1, -1, 1], LARGE_TOP = 1071, QUADRANT_ROUND = 8388608, INV_PIO4 = [
+  162,
+  41721,
+  10680707,
+  2734261102,
+  4186140238,
+  2205044292,
+  1850622997,
+  1313084713,
+  1142237692,
+  355073063,
+  704390999,
+  4230436817,
+  660066805,
+  1473377588,
+  3522507997,
+  4113882560,
+  886948059,
+  3720403810,
+  3235603093,
+  3680671129,
+  1653971260,
+  2509847619,
+  2570863504,
+  1011060801
+], QUARTER_PI = Math.PI / 4, HALF_PI = Math.PI / 2, TAN_PI_8 = d("3fda827999fcef34"), ATAN_TERMS = 14, ATAN_COEFFS = Array.from({ length: (14) }, (_, k) => (k % 2 === 0 ? 1 : -1) * (1 / (2 * k + 1))), U64 = (1n << 64n) - 1n, U32 = (1n << 32n) - 1n;
+function clampTo(x, low2, high2) {
+  return Number.isNaN(x) ? low2 : Math.min(Math.max(x, low2), high2);
+}
+function exp2Table(xd, shift, poly2, signBias) {
+  let shifted = xd + shift, ki = lowWord(shifted), kd = shifted - shift, r = xd - kd, i = ki & 31, hi = EXP2_HI[i] + (ki + signBias >>> 0 << 15) >>> 0, s = f64From(hi, EXP2_LO[i]), z = poly2[0] * r + poly2[1], r2 = r * r, y = poly2[2] * r + 1;
+  return (z * r2 + y) * s;
+}
+function exp(x) {
+  return Number.isNaN(x) ? Number.NaN : fround(exp2Table(INV_LN2_N * clampTo(x, (-104), (89)), SHIFT, EXP_POLY, 0));
+}
+function exp2(x) {
+  return Number.isNaN(x) ? Number.NaN : fround(exp2Table(clampTo(x, (-151), (129)), SHIFT_SCALED, EXP2_POLY, 0));
+}
+function normalized(ix) {
+  let abs = (ix & (2147483647)) >>> 0;
+  return abs >= (8388608) ? abs : f32Bits(fround(f32From(abs) * (8388608))) - SUBNORMAL_BIAS >>> 0;
+}
+function split(ix) {
+  let tmp = ix - (1060306944) >>> 0, i = tmp >>> 19 & 15, top = (tmp & (4286578688)) >>> 0, k = (top | 0) >> 23, z = f32From(ix - top >>> 0);
+  return [i, k, z * INV_C[i] - 1];
+}
+function logSpecial(x, y) {
+  let ix = f32Bits(x);
+  return ix << 1 >>> 0 ? ix === (2139095040) ? x : (ix & (2147483648)) !== 0 || ix << 1 >>> 0 >= (2139095040) << 1 >>> 0 ? Number.NaN : y : Number.NEGATIVE_INFINITY;
+}
+function log(x) {
+  let [i, k, r] = split(normalized(f32Bits(x))), y0 = LOG_C[i] + k * LN2, r2 = r * r, y = LOG_POLY[1] * r + LOG_POLY[2];
+  return y = LOG_POLY[0] * r2 + y, y = y * r2 + (y0 + r), logSpecial(fround(x), fround(y));
+}
+function log2(x) {
+  let [i, k, r] = split(normalized(f32Bits(x))), y0 = LOG2_C[i] + k, r2 = r * r, y = LOG2_POLY[1] * r + LOG2_POLY[2];
+  y = LOG2_POLY[0] * r2 + y;
+  let p = LOG2_POLY[3] * r + y0;
+  return y = y * r2 + p, logSpecial(fround(x), fround(y));
+}
+function powLog2(ix) {
+  let [i, k, r] = split(ix), y0 = LOG2_C[i] + k, r2 = r * r, y = POW_POLY[0] * r + POW_POLY[1], p = POW_POLY[2] * r + POW_POLY[3], r4 = r2 * r2, q = POW_POLY[4] * r + y0;
+  return q = p * r2 + q, y * r4 + q;
+}
+function integerKind(iy) {
+  let e = iy >>> 23 & 255;
+  if (e < 127) return 0;
+  if (e > 150) return 2;
+  let shift = 150 - e;
+  return (shift === 0 ? 0 : (iy & (1 << shift >>> 0) - 1) >>> 0) !== 0 ? 0 : (iy & 1 << shift >>> 0) !== 0 ? 1 : 2;
+}
+function zeroInfNan(i) {
+  return (i << 1 >>> 0) - 1 >>> 0 >= ((2139095040) << 1 >>> 0) - 1 >>> 0;
+}
+function pow(xIn, yIn) {
+  let x = fround(xIn), y = fround(yIn), ix = f32Bits(x), iy = f32Bits(y), ax = ix << 1 >>> 0 >>> 1;
+  if (zeroInfNan(iy))
+    return !(iy << 1 >>> 0) || ix === (1065353216) ? 1 : ix << 1 >>> 0 > (2139095040) << 1 >>> 0 || iy << 1 >>> 0 > (2139095040) << 1 >>> 0 ? Number.NaN : ax === (1065353216) ? 1 : ax < (1065353216) == ((iy & (2147483648)) === 0) ? 0 : fround(y * y);
+  let yint = integerKind(iy), negative = (ix & (2147483648)) !== 0, odd = negative && yint === 1;
+  if (zeroInfNan(ix)) {
+    if (Number.isNaN(x)) return Number.NaN;
+    let square = fround(x * x), x2 = odd ? -square : square;
+    return (iy & (2147483648)) !== 0 ? fround(1 / x2) : x2;
+  }
+  if (negative && yint === 0) return Number.NaN;
+  let ylogx = y * powLog2(normalized(ix)), signed = (magnitude) => odd ? -magnitude : magnitude;
+  return ylogx > POW_OVERFLOW ? signed(Number.POSITIVE_INFINITY) : ylogx > POW_SATURATE ? signed(F32_MAX) : ylogx <= (-150) ? signed(0) : fround(exp2Table(clampTo(ylogx, (-151), (129)), SHIFT_SCALED, EXP2_POLY, odd ? (65536) : 0));
+}
+function poly(x, n, flip, s) {
+  let xs = x * s, x2 = x * x, x3 = x2 * xs, x4 = x2 * x2, x5 = x3 * x2, x6 = x4 * x2, c2 = COS_C3 * flip + x2 * (COS_C4 * flip), s1 = SIN_S2 + x2 * SIN_S3, c1 = flip + x2 * (COS_C1 * flip), sv = xs + x3 * SIN_S1, cv = c1 + x4 * (COS_C2 * flip), sine = sv + x5 * s1, cosine = cv + x6 * c2;
+  return (n & 1) !== 0 ? [cosine, sine] : [sine, cosine];
+}
+function sincosWide(xIn) {
+  let x = fround(xIn), bits = f32Bits(x);
+  if ((bits >>> 20 & 2047) < (1071)) {
+    let n2 = (x * HPI_INV | 0) + (8388608) >> 24;
+    return poly(x - n2 * HPI, n2, (n2 & 2) !== 0 ? -1 : 1, QUADRANT_SIGN[n2 & 3]);
+  }
+  if (!Number.isFinite(x)) return [Number.NaN, Number.NaN];
+  let sign = bits >>> 31, at = bits >>> 26 & 15, shift = bits >>> 23 & 7, m = BigInt((bits & 16777215 | 8388608) << shift >>> 0), res0 = m * BigInt(INV_PIO4[at]) & U32, res1 = m * BigInt(INV_PIO4[at + 4]), res = (m * BigInt(INV_PIO4[at + 8]) >> 32n | res0 << 32n) & U64;
+  res = res + res1 & U64;
+  let n = (res + (1n << 61n) & U64) >> 62n;
+  res = res - (n << 62n) & U64;
+  let signedRes = res >= 1n << 63n ? res - (1n << 64n) : res, reduced2 = Number(signedRes) * PI63, quadrant = Number(n) + sign | 0;
+  return poly(reduced2, Number(n), (quadrant & 2) !== 0 ? -1 : 1, QUADRANT_SIGN[quadrant & 3]);
+}
+function sin(x) {
+  return fround(sincosWide(x)[0]);
+}
+function cos(x) {
+  return fround(sincosWide(x)[1]);
+}
+function tan(x) {
+  let [s, c] = sincosWide(x);
+  return fround(s / c);
+}
+function atanUnit(t) {
+  let big = t > TAN_PI_8, u = big ? (t - 1) / (t + 1) : t, u2 = u * u, p = 0;
+  for (let k = (14) - 1; k >= 0; k--) p = ATAN_COEFFS[k] + u2 * p;
+  return (big ? QUARTER_PI : 0) + u * p;
+}
+function atan2Wide(y, x) {
+  if (Number.isNaN(x) || Number.isNaN(y)) return Number.NaN;
+  let ax = Math.abs(x), ay = Math.abs(y), high2 = Math.max(ax, ay), low2 = Math.min(ax, ay), t = high2 === 0 ? 0 : low2 === Number.POSITIVE_INFINITY ? 1 : low2 / high2, v = atanUnit(t);
+  return ay > ax && (v = HALF_PI - v), (x < 0 || Object.is(x, -0)) && (v = Math.PI - v), y < 0 || Object.is(y, -0) ? -v : v;
+}
+function atan2(y, x) {
+  return fround(atan2Wide(fround(y), fround(x)));
+}
+function atan(x) {
+  return fround(atan2Wide(fround(x), 1));
+}
+function asin(xIn) {
+  let x = fround(xIn);
+  return Math.abs(x) > 1 ? Number.NaN : fround(atan2Wide(x, Math.sqrt((1 - x) * (1 + x))));
+}
+function acos(xIn) {
+  let x = fround(xIn);
+  return Math.abs(x) > 1 ? Number.NaN : fround(atan2Wide(Math.sqrt((1 - x) * (1 + x)), x));
+}
+var FMATH_CONSTANTS = {
+  EXP2_HI,
+  EXP2_LO,
+  EXP2_POLY,
+  EXP_POLY,
+  INV_LN2_N,
+  SHIFT,
+  SHIFT_SCALED,
+  EXP_LOW: (-104),
+  EXP_HIGH: (89),
+  EXP2_LOW: (-151),
+  EXP2_HIGH: (129),
+  INV_C,
+  LOG_C,
+  LOG2_C,
+  LN2,
+  LOG_POLY,
+  LOG2_POLY,
+  POW_POLY,
+  POW_SIGN_BIAS: (65536),
+  POW_OVERFLOW,
+  POW_SATURATE,
+  POW_UNDERFLOW: (-150),
+  LOG_OFF: (1060306944),
+  SUBNORMAL_SCALE: (8388608),
+  SUBNORMAL_BIAS,
+  MIN_NORMAL: (8388608),
+  INFINITY_BITS: (2139095040),
+  ONE_BITS: (1065353216),
+  F32_MAX,
+  HPI_INV,
+  HPI,
+  PI63,
+  COS_C1,
+  COS_C2,
+  COS_C3,
+  COS_C4,
+  SIN_S1,
+  SIN_S2,
+  SIN_S3,
+  LARGE_TOP: (1071),
+  QUADRANT_ROUND: (8388608),
+  INV_PIO4,
+  QUARTER_PI,
+  HALF_PI,
+  TAN_PI_8,
+  ATAN_COEFFS
+};
+
+// src/game/kernel/isa.ts
+var isa_exports = {};
+chunkJGBCIKJV_js.__export(isa_exports, {
+  ACCESS_ARRAY: () => (65536),
+  ACCESS_HIGH: () => (4096),
+  ACCESS_INDEXED: () => ACCESS_INDEXED,
+  ACCESS_NEIGHBOUR: () => (1024),
+  ACCESS_POOL: () => ACCESS_POOL,
+  ACCESS_READ: () => (256),
+  ACCESS_SCRATCH: () => (2048),
+  ACCESS_SPAWN: () => (8192),
+  ACCESS_TABLE: () => ACCESS_TABLE,
+  ACCESS_TABLE_MASK: () => (15),
+  ACCESS_TABLE_SHIFT: () => (19),
+  ACCESS_WRITE: () => (512),
+  ARG_FMAX: () => (1),
+  ARG_FMIN: () => (0),
+  ARG_IMAX: () => (3),
+  ARG_IMIN: () => (2),
+  ARG_UMAX: () => (5),
+  ARG_UMIN: () => (4),
+  ATTACH_AUDIO: () => (5),
+  ATTACH_CHEMISTRY_GRID: () => (7),
+  ATTACH_SPAWN_TABLE: () => (9),
+  ATTACH_UI: () => (4),
+  ATTACH_VOXELS: () => (6),
+  CELL_WRAP: () => CELL_WRAP,
+  CHANNEL_WORDS: () => (4),
+  CROSS_BLOCK: () => (256),
+  CROSS_OP: () => CROSS_OP,
+  CURVE_BEZIER: () => (3),
+  CURVE_HEADER: () => (4),
+  CURVE_HERMITE: () => (2),
+  CURVE_LINEAR: () => (1),
+  CURVE_MAX_CHANNELS: () => (4),
+  CURVE_MAX_KEYS: () => (256),
+  CURVE_STEP: () => (0),
+  DATA_FLOAD: () => (12290),
+  DATA_KEYOF: () => (12288),
+  DATA_LIST: () => (12304),
+  DATA_LIST_MAX: () => (4096),
+  DATA_PGET: () => (12305),
+  DATA_PICK: () => (12336),
+  DATA_PSET: () => (12306),
+  DATA_REPORT_HEADER: () => (70),
+  DATA_ROWOF: () => (12289),
+  DATA_ROWS: () => (12291),
+  DATA_SEND: () => (12320),
+  DATA_TABLES: () => (16),
+  DATA_TALLIES: () => (64),
+  DATA_TALLY: () => (12307),
+  DEFAULT_EVENT_CAPACITY: () => (4096),
+  DST_BITS: () => (8),
+  EVENT_HEADER_WORDS: () => (2),
+  EVENT_STRIDE: () => (10),
+  FIELD_MAX: () => (64),
+  FLAG_GROUPS: () => (2),
+  FLAG_NEIGHBOURS: () => (1),
+  GRAPH_EMPTY: () => (4294967295),
+  GROUP_DEFAULT: () => (1),
+  GROUP_WORDS: () => (4),
+  H_ARGS: () => (5),
+  H_CONSTANTS: () => (6),
+  H_EVENTS: () => (14),
+  H_FLAGS: () => (2),
+  H_GROUPS: () => (9),
+  H_INSTRUCTIONS: () => (8),
+  H_LOOPS: () => (7),
+  H_MAGIC: () => (0),
+  H_POSITION_X: () => (11),
+  H_POSITION_Y: () => (12),
+  H_POSITION_Z: () => (13),
+  H_REGISTERS: () => (3),
+  H_SLOTS: () => (4),
+  H_STATE: () => (10),
+  H_VERSION: () => (1),
+  INSTRUCTION_WORDS: () => (4),
+  KERNEL_CALLS_FEATURE: () => KERNEL_CALLS_FEATURE,
+  KERNEL_CALL_EXPORT_NAMES: () => KERNEL_CALL_EXPORT_NAMES,
+  KERNEL_DATA_EXPORT_NAMES: () => KERNEL_DATA_EXPORT_NAMES,
+  KERNEL_EXPORT_NAMES: () => KERNEL_EXPORT_NAMES,
+  KERNEL_EXTENDED_FEATURE: () => KERNEL_EXTENDED_FEATURE,
+  KERNEL_FEATURE: () => KERNEL_FEATURE,
+  KERNEL_GATHER_FEATURE: () => KERNEL_GATHER_FEATURE,
+  KERNEL_ISA_BASE: () => (1),
+  KERNEL_ISA_CALLS: () => (2),
+  KERNEL_ISA_EXTENDED: () => (4),
+  KERNEL_ISA_VERSION: () => (4),
+  KERNEL_ISA_WRITES: () => (3),
+  KERNEL_LIBRARY_PATH: () => KERNEL_LIBRARY_PATH,
+  KERNEL_MLP_FEATURE: () => KERNEL_MLP_FEATURE,
+  KERNEL_MOE_FEATURE: () => KERNEL_MOE_FEATURE,
+  KERNEL_QUERY_RANK_FEATURE: () => KERNEL_QUERY_RANK_FEATURE,
+  KERNEL_SCAN_FEATURE: () => KERNEL_SCAN_FEATURE,
+  KERNEL_SIMD_FEATURE: () => KERNEL_SIMD_FEATURE,
+  KERNEL_STAGE_EXPORT_NAMES: () => KERNEL_STAGE_EXPORT_NAMES,
+  KERNEL_WRITES_FEATURE: () => KERNEL_WRITES_FEATURE,
+  KERNEL_WRITE_EXPORT_NAMES: () => KERNEL_WRITE_EXPORT_NAMES,
+  KIND_BOOL: () => (3),
+  KIND_F32: () => (0),
+  KIND_I32: () => (1),
+  KIND_U32: () => (2),
+  LIBRARY_HEADER_WORDS: () => (4),
+  LIBRARY_MAGIC: () => (827083587),
+  LOOKUP_OP: () => LOOKUP_OP,
+  LOOP_COUNT_F32: () => (1),
+  LUT1_HEADER: () => (4),
+  LUT1_MAX: () => (65536),
+  LUT2_HEADER: () => (8),
+  LUT2_MAX: () => LUT2_MAX,
+  LUT_LINEAR: () => (1),
+  LUT_WRAP: () => (2),
+  MAX_CHANNELS: () => (64),
+  MAX_EVENT_WORDS: () => (8),
+  MAX_GROUPS: () => (256),
+  MAX_REGISTERS: () => (4096),
+  MAX_SLOTS: () => (256),
+  MAX_SPAWN_FIELDS: () => (64),
+  MAX_TRIPS: () => (65536),
+  MAX_UNIFORMS: () => (4096),
+  MLP_MAX_OUTPUTS: () => (32),
+  MLP_MAX_WIDTH: () => (128),
+  NONE: () => (4294967295),
+  Op: () => Op,
+  PICK_F32: () => (1),
+  PICK_U32: () => (0),
+  PROGRAM_HEADER_WORDS: () => (16),
+  PROGRAM_MAGIC: () => (827345731),
+  QFILTER_ANY: () => (2),
+  QFILTER_EQUAL: () => (1),
+  QFILTER_NONE: () => (3),
+  QUERY_BOX: () => (2),
+  QUERY_CONE: () => (1),
+  QUERY_FILTERED: () => (4),
+  QUERY_SEGMENT: () => (3),
+  QUERY_SHAPE: () => (3),
+  QUERY_SPHERE: () => (0),
+  RECUR: () => RECUR,
+  RECUR_EXCLUSIVE: () => (32),
+  RECUR_KINDS: () => (17),
+  RECUR_KIND_MASK: () => (31),
+  RECUR_WIDE: () => (64),
+  REDUCE_FMAX: () => (3),
+  REDUCE_FMIN: () => (2),
+  REDUCE_FSUM: () => (0),
+  REDUCE_IMAX: () => (5),
+  REDUCE_IMIN: () => (4),
+  REDUCE_ISUM: () => (1),
+  REDUCE_UMAX: () => (7),
+  REDUCE_UMIN: () => (6),
+  RING_COUNT: () => (0),
+  RING_DROPPED: () => (1),
+  RING_HEADER_WORDS: () => (2),
+  SAMPLER_WORDS: () => (8),
+  SAMPLE_BILINEAR: () => (1),
+  SAMPLE_NEAREST: () => (0),
+  SAMPLE_NORMAL_X: () => (2),
+  SAMPLE_NORMAL_Y: () => (3),
+  SAMPLE_NORMAL_Z: () => (4),
+  SCAN_F_EXCLUSIVE: () => (1),
+  SCAN_F_INCLUSIVE: () => (0),
+  SCAN_I_EXCLUSIVE: () => (3),
+  SCAN_I_INCLUSIVE: () => (2),
+  SCATTER_FADD: () => (0),
+  SCATTER_IADD: () => (1),
+  SEND: () => SEND,
+  SERVICE_ANCHOR: () => (16),
+  SERVICE_BITS: () => (8),
+  SERVICE_CHEMISTRY: () => (21),
+  SERVICE_CLIP_WEIGHT: () => (11),
+  SERVICE_FLOW: () => (5),
+  SERVICE_FORCE: () => (6),
+  SERVICE_GROUND_HEIGHT: () => (3),
+  SERVICE_IK_TARGET: () => (13),
+  SERVICE_IMPULSE: () => (7),
+  SERVICE_INSTANCE: () => (14),
+  SERVICE_INSTANCE_COLOUR: () => (15),
+  SERVICE_KILL: () => (23),
+  SERVICE_LINE_OF_SIGHT: () => (2),
+  SERVICE_MASK: () => (255),
+  SERVICE_OVERLAP: () => (9),
+  SERVICE_PATH: () => (4),
+  SERVICE_PICK: () => (18),
+  SERVICE_PLAY_CLIP: () => (12),
+  SERVICE_RAYCAST: () => (1),
+  SERVICE_SIGNATURES: () => SERVICE_SIGNATURES,
+  SERVICE_SOUND: () => (17),
+  SERVICE_SPAWN: () => (22),
+  SERVICE_SWEEP: () => (10),
+  SERVICE_VELOCITY: () => (8),
+  SERVICE_VOXEL_GET: () => (19),
+  SERVICE_VOXEL_SET: () => (20),
+  SIMD_CROSS: () => (28948),
+  SIMD_CROSS_WIDTH: () => (3),
+  SIMD_DOT: () => (28944),
+  SIMD_DOT_F32: () => (0),
+  SIMD_DOT_I32: () => (1),
+  SIMD_EXTRACT: () => (28929),
+  SIMD_LANE_BITS: () => (3),
+  SIMD_LANE_MASK: () => SIMD_LANE_MASK,
+  SIMD_LENGTH: () => (28946),
+  SIMD_MAP: () => (28672),
+  SIMD_MAP_OPS: () => (256),
+  SIMD_MAX_WIDTH: () => (4),
+  SIMD_MIN_WIDTH: () => (2),
+  SIMD_NORMALIZE: () => (28947),
+  SIMD_PACK: () => (28931),
+  SIMD_REDUCE: () => (28945),
+  SIMD_REPLACE: () => (28930),
+  SIMD_SCALAR_A: () => (8),
+  SIMD_SCALAR_B: () => (16),
+  SIMD_SCALAR_C: () => (32),
+  SIMD_SHUFFLE: () => (28928),
+  SIMD_WIDTH_MASK: () => (7),
+  SORT_DESCENDING: () => (4),
+  SORT_KEY_F32: () => (2),
+  SORT_KEY_I32: () => (1),
+  SORT_KEY_MASK: () => (3),
+  SORT_KEY_U32: () => (0),
+  SORT_RADIX_BITS: () => (8),
+  SPAWN_STATS_WORDS: () => (3),
+  STATUS_FAILURE: () => (0),
+  STATUS_RUNNING: () => (2),
+  STATUS_SUCCESS: () => (1),
+  UNIFORM: () => (2147483648),
+  XOP: () => (175),
+  XOP_COMPONENTS_EDGES: () => (20483),
+  XOP_COMPONENTS_GRID: () => (20480),
+  XOP_DEDUP: () => (4),
+  XOP_FIELD: () => (17),
+  XOP_GATHER: () => (16),
+  XOP_GROUP: () => (3),
+  XOP_MAX: () => (65535),
+  XOP_MLP_IN: () => (24576),
+  XOP_MLP_MOE: () => (24579),
+  XOP_MLP_OUT: () => (24578),
+  XOP_MLP_RUN: () => (24577),
+  XOP_PROPAGATE_GRID: () => (20482),
+  XOP_QFILTER: () => (4098),
+  XOP_QRANK: () => (4100),
+  XOP_QSHAPE: () => (4097),
+  XOP_QSTOP: () => (4099),
+  XOP_QUERY: () => (4096),
+  XOP_RANGE: () => XOP_RANGE,
+  XOP_RANGE_SHIFT: () => (12),
+  XOP_REACH_GRID: () => (20481),
+  XOP_RECUR: () => (32),
+  XOP_RECUR_IN: () => (33),
+  XOP_SORT: () => (1),
+  XOP_TOPK: () => (2),
+  crossRow: () => crossRow,
+  curveWords: () => curveWords,
+  deferredService: () => deferredService,
+  lookupOp: () => lookupOp,
+  operandCount: () => operandCount,
+  recurCoefficient: () => recurCoefficient,
+  recurFloatOutput: () => recurFloatOutput,
+  recurStateWords: () => recurStateWords,
+  recurSub: () => recurSub,
+  serviceOf: () => serviceOf,
+  serviceVersion: () => serviceVersion,
+  sortKey: () => sortKey,
+  stageEndingOp: () => stageEndingOp,
+  stageEnds: () => stageEnds,
+  xopRange: () => xopRange
+});
+var KERNEL_ISA_VERSION = 4, KERNEL_ISA_BASE = 1, KERNEL_ISA_CALLS = 2, KERNEL_ISA_WRITES = 3, KERNEL_FEATURE = "kernel_isa_1", KERNEL_CALLS_FEATURE = "kernel_isa_2", KERNEL_WRITES_FEATURE = "kernel_isa_3", KERNEL_ISA_EXTENDED = 4, KERNEL_EXTENDED_FEATURE = "kernel_isa_4", PROGRAM_MAGIC = 827345731, LIBRARY_MAGIC = 827083587, PROGRAM_HEADER_WORDS = 16, LIBRARY_HEADER_WORDS = 4, INSTRUCTION_WORDS = 4, GROUP_WORDS = 4, NONE = 4294967295, UNIFORM = 2147483648, DST_BITS = 8, MAX_REGISTERS = 4096, MAX_SLOTS = 256, MAX_UNIFORMS = 4096, MAX_GROUPS = 256, MAX_TRIPS = 65536, KERNEL_LIBRARY_PATH = "kernels.ckl", H_MAGIC = 0, H_VERSION = 1, H_FLAGS = 2, H_REGISTERS = 3, H_SLOTS = 4, H_ARGS = 5, H_CONSTANTS = 6, H_LOOPS = 7, H_INSTRUCTIONS = 8, H_GROUPS = 9, H_STATE = 10, H_POSITION_X = 11, H_POSITION_Y = 12, H_POSITION_Z = 13, H_EVENTS = 14, CHANNEL_WORDS = 4, MAX_CHANNELS = 64, MAX_EVENT_WORDS = 8, EVENT_HEADER_WORDS = 2, EVENT_STRIDE = 10, FLAG_NEIGHBOURS = 1, FLAG_GROUPS = 2, KIND_F32 = 0, KIND_I32 = 1, KIND_U32 = 2, KIND_BOOL = 3, ACCESS_READ = 256, ACCESS_WRITE = 512, ACCESS_NEIGHBOUR = 1024, ACCESS_SCRATCH = 2048, ACCESS_HIGH = 4096, ACCESS_SPAWN = 8192, SERVICE_RAYCAST = 1, SERVICE_LINE_OF_SIGHT = 2, SERVICE_GROUND_HEIGHT = 3, SERVICE_PATH = 4, SERVICE_FLOW = 5, SERVICE_FORCE = 6, SERVICE_IMPULSE = 7, SERVICE_VELOCITY = 8, SERVICE_OVERLAP = 9, SERVICE_SWEEP = 10, SERVICE_CLIP_WEIGHT = 11, SERVICE_PLAY_CLIP = 12, SERVICE_IK_TARGET = 13, SERVICE_INSTANCE = 14, SERVICE_INSTANCE_COLOUR = 15, SERVICE_ANCHOR = 16, SERVICE_SOUND = 17, SERVICE_PICK = 18, SERVICE_VOXEL_GET = 19, SERVICE_VOXEL_SET = 20, SERVICE_CHEMISTRY = 21, SERVICE_SPAWN = 22, SERVICE_KILL = 23, SERVICE_BITS = 8, SERVICE_MASK = 255, MAX_SPAWN_FIELDS = 64;
+function serviceOf(dst) {
+  return dst & 255;
+}
+function operandCount(dst) {
+  return dst >>> 8;
+}
+function serviceVersion(service) {
+  return service >= 6 ? 3 : 2;
+}
+function deferredService(service) {
+  return service === 22 || service === 23;
+}
+var PHYSICS_WRITE = { args: [2, 0, 0, 0], results: [] }, SERVICE_SIGNATURES = {
+  1: { args: [0, 0, 0, 0, 0, 0, 0], results: [0, 0, 0, 0, 2, 3] },
+  2: { args: [0, 0, 0, 0, 0, 0], results: [3] },
+  3: { args: [0, 0], results: [0] },
+  4: { args: [0, 0, 0, 0, 0, 0], results: [0, 0, 0, 2] },
+  5: { args: [0, 0, 0], results: [0, 0, 0, 0, 2] },
+  6: PHYSICS_WRITE,
+  7: PHYSICS_WRITE,
+  8: PHYSICS_WRITE,
+  9: { args: [0, 0, 0, 0], results: [2, 2] },
+  10: { args: [0, 0, 0, 0, 0, 0, 0, 0, 2], results: [0, 0, 0, 0, 2, 3] },
+  11: { args: [2, 0], results: [] },
+  12: { args: [2, 2, 3, 0, 0], results: [2] },
+  13: { args: [2, 0, 0, 0, 0], results: [] },
+  14: { args: [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], results: [] },
+  15: { args: [2, 2, 0, 0, 0, 0], results: [] },
+  16: { args: [2, 0, 0, 0], results: [] },
+  17: { args: [2, 2, 0, 0, 0, 0], results: [] },
+  18: { args: [0, 0, 0, 0, 0, 0, 0], results: [0, 2, 2, 3] },
+  19: { args: [0, 0, 0], results: [2, 3] },
+  20: { args: [0, 0, 0, 2], results: [] },
+  21: { args: [2, 2, 2], results: [2, 0, 2] },
+  23: { args: [], results: [] }
+}, ATTACH_UI = 4, ATTACH_AUDIO = 5, ATTACH_VOXELS = 6, ATTACH_CHEMISTRY_GRID = 7, ATTACH_SPAWN_TABLE = 9, SPAWN_STATS_WORDS = 3, GROUP_DEFAULT = 1, LOOP_COUNT_F32 = 1, Op = {
+  NOP: 0,
+  MOV: 1,
+  LOAD: 2,
+  STORE: 3,
+  ROW: 4,
+  SEL: 5,
+  JNONE: 6,
+  LOOP_INIT: 8,
+  LOOP_NEXT: 9,
+  NEIGHBOURS: 11,
+  NLOAD: 12,
+  OUTER: 13,
+  NROW: 14,
+  ACC_FADD: 15,
+  ACC_FMIN: 16,
+  ACC_FMAX: 17,
+  ACC_IADD: 18,
+  EXT: 19,
+  FADD: 20,
+  FSUB: 21,
+  FMUL: 22,
+  FDIV: 23,
+  FMIN: 24,
+  FMAX: 25,
+  FMOD: 26,
+  FPOW: 27,
+  FATAN2: 28,
+  FMULADD: 29,
+  FMULSUB: 30,
+  FSUBMUL: 31,
+  FADDMUL: 32,
+  FCLAMP: 33,
+  FLERP: 34,
+  FLOG2: 39,
+  FNEG: 40,
+  FABS: 41,
+  FSQRT: 42,
+  FFLOOR: 43,
+  FCEIL: 44,
+  FROUND: 45,
+  FTRUNC: 46,
+  FSIGN: 47,
+  FSIN: 48,
+  FCOS: 49,
+  FTAN: 50,
+  FASIN: 51,
+  FACOS: 52,
+  FATAN: 53,
+  FEXP: 54,
+  FLOG: 55,
+  FLEN2: 56,
+  FLEN3: 57,
+  FDOT2: 58,
+  FDOT3: 59,
+  FLT: 60,
+  FLE: 61,
+  FEQ: 62,
+  FNE: 63,
+  IADD: 70,
+  ISUB: 71,
+  IMUL: 72,
+  IREM: 73,
+  UREM: 74,
+  IAND: 75,
+  IOR: 76,
+  IXOR: 77,
+  ISHL: 78,
+  ISHR: 79,
+  IUSHR: 80,
+  IMIN: 81,
+  IMAX: 82,
+  UMIN: 83,
+  UMAX: 84,
+  INEG: 85,
+  IABS: 86,
+  INOT: 87,
+  ILT: 90,
+  ILE: 91,
+  IEQ: 92,
+  INE: 93,
+  ULT: 94,
+  ULE: 95,
+  ITOF: 100,
+  UTOF: 101,
+  FTOI: 102,
+  BTOF: 103,
+  BTOI: 104,
+  FTOB: 105,
+  ITOB: 106,
+  MAND: 110,
+  MOR: 111,
+  MANDN: 112,
+  MNOT: 113,
+  NOISE2: 120,
+  NOISE3: 121,
+  HASH: 122,
+  RAND: 123,
+  EMIT: 124,
+  CALL: 125,
+  UADDC: 126,
+  USUBB: 127,
+  UMULHI: 128
+}, STATUS_FAILURE = 0, STATUS_SUCCESS = 1, STATUS_RUNNING = 2, KERNEL_EXPORT_NAMES = [
+  "engine_kernel_isa",
+  "engine_kernel_load",
+  "engine_kernel_unload",
+  "engine_kernel_bind",
+  "engine_kernel_unbind",
+  "engine_kernel_run",
+  "engine_kernel_events",
+  "engine_kernel_clear_events"
+], KERNEL_CALL_EXPORT_NAMES = ["engine_kernel_attach"], KERNEL_WRITE_EXPORT_NAMES = ["engine_kernel_attach_handle", "engine_kernel_spawns"], KERNEL_STAGE_EXPORT_NAMES = [
+  "engine_kernel_stage_begin",
+  "engine_kernel_stage_uniforms",
+  "engine_kernel_stage_column",
+  "engine_kernel_stage_storage",
+  "engine_kernel_stage_records",
+  "engine_kernel_stage_call",
+  "engine_kernel_stage_finish",
+  "engine_kernel_stage_end"
+], KERNEL_DATA_EXPORT_NAMES = ["engine_kernel_bind_table", "engine_kernel_bind_pool", "engine_kernel_data"], DATA_REPORT_HEADER = 70, RING_HEADER_WORDS = 2, RING_COUNT = 0, RING_DROPPED = 1, DEFAULT_EVENT_CAPACITY = 4096, CROSS_OP = {
+  REDUCE: 160,
+  ARG: 161,
+  HIST: 162,
+  SCATTER: 163,
+  SCAN: 164,
+  COMPACT: 165
+}, ACCESS_ARRAY = 65536, CROSS_BLOCK = 256, REDUCE_FSUM = 0, REDUCE_ISUM = 1, REDUCE_FMIN = 2, REDUCE_FMAX = 3, REDUCE_IMIN = 4, REDUCE_IMAX = 5, REDUCE_UMIN = 6, REDUCE_UMAX = 7, ARG_FMIN = 0, ARG_FMAX = 1, ARG_IMIN = 2, ARG_IMAX = 3, ARG_UMIN = 4, ARG_UMAX = 5, SCATTER_FADD = 0, SCATTER_IADD = 1, SCAN_F_INCLUSIVE = 0, SCAN_F_EXCLUSIVE = 1, SCAN_I_INCLUSIVE = 2, SCAN_I_EXCLUSIVE = 3;
+function crossRow(op) {
+  return op >= CROSS_OP.REDUCE && op <= CROSS_OP.COMPACT;
+}
+var LOOKUP_OP = {
+  CURVE: 176,
+  LUT1: 177,
+  LUT2: 178,
+  SAMPLE: 179,
+  CELL: 180
+}, ACCESS_INDEXED = 1 << 18, CURVE_STEP = 0, CURVE_LINEAR = 1, CURVE_HERMITE = 2, CURVE_BEZIER = 3, CURVE_HEADER = 4, CURVE_MAX_KEYS = 256, CURVE_MAX_CHANNELS = 4, LUT1_HEADER = 4, LUT1_MAX = 65536, LUT2_HEADER = 8, LUT2_MAX = 1 << 20, LUT_LINEAR = 1, LUT_WRAP = 2, SAMPLER_WORDS = 8, SAMPLE_NEAREST = 0, SAMPLE_BILINEAR = 1, SAMPLE_NORMAL_X = 2, SAMPLE_NORMAL_Y = 3, SAMPLE_NORMAL_Z = 4, CELL_WRAP = 1 << 24;
+function lookupOp(op) {
+  return op >= LOOKUP_OP.CURVE && op <= LOOKUP_OP.CELL;
+}
+var XOP_QUERY = 4096, XOP_QSHAPE = 4097, XOP_QFILTER = 4098, XOP_QSTOP = 4099, XOP_QRANK = 4100, KERNEL_QUERY_RANK_FEATURE = "kernel_query_rank_1", QUERY_SPHERE = 0, QUERY_CONE = 1, QUERY_BOX = 2, QUERY_SEGMENT = 3, QUERY_SHAPE = 3, QUERY_FILTERED = 4, QFILTER_EQUAL = 1, QFILTER_ANY = 2, QFILTER_NONE = 3;
+function curveWords(kind, keys, channels) {
+  let per = kind === (2) ? 2 : kind === (3) ? 3 : 1;
+  return (4) + keys + keys * channels * per;
+}
+var XOP = 175, XOP_MAX = 65535, XOP_RANGE_SHIFT = 12, XOP_RANGE = { CROSS: 0, SAMPLING: 1, NARROW: 2, DATA: 3, STDLIB: 4, SYSTEMS: 5, NEURAL: 6, SIMD: 7 }, XOP_MLP_IN = 24576, XOP_MLP_RUN = 24577, XOP_MLP_OUT = 24578, XOP_MLP_MOE = 24579, KERNEL_MOE_FEATURE = "kernel_moe_1", MLP_MAX_WIDTH = 128, MLP_MAX_OUTPUTS = 32, SIMD_MAP = 28672, SIMD_MAP_OPS = 256, SIMD_SHUFFLE = 28928, SIMD_EXTRACT = 28929, SIMD_REPLACE = 28930, SIMD_PACK = 28931, SIMD_DOT = 28944, SIMD_REDUCE = 28945, SIMD_LENGTH = 28946, SIMD_NORMALIZE = 28947, SIMD_CROSS = 28948, SIMD_MIN_WIDTH = 2, SIMD_MAX_WIDTH = 4, SIMD_WIDTH_MASK = 7, SIMD_SCALAR_A = 8, SIMD_SCALAR_B = 16, SIMD_SCALAR_C = 32, SIMD_LANE_BITS = 3, SIMD_LANE_MASK = (1 << (3)) - 1, SIMD_DOT_F32 = 0, SIMD_DOT_I32 = 1, SIMD_CROSS_WIDTH = 3, KERNEL_SIMD_FEATURE = "kernel_simd_1";
+function xopRange(sub) {
+  return sub >>> (12);
+}
+var ACCESS_TABLE_SHIFT = 19, ACCESS_TABLE_MASK = 15, ACCESS_TABLE = (15) << (19), ACCESS_POOL = 1 << 23, DATA_TABLES = 16, DATA_KEYOF = 12288, DATA_ROWOF = 12289, DATA_FLOAD = 12290, DATA_ROWS = 12291, DATA_LIST = 12304, DATA_PGET = 12305, DATA_PSET = 12306, DATA_TALLY = 12307, DATA_SEND = 12320, DATA_PICK = 12336, DATA_LIST_MAX = 4096, DATA_TALLIES = 64, SEND = { SET: 0, FADD: 1, FMUL: 2, FMIN: 3, FMAX: 4, IADD: 5, IMIN: 6, IMAX: 7, UMIN: 8, UMAX: 9, OR: 10, AND: 11, PUSH: 12 }, PICK_U32 = 0, PICK_F32 = 1, XOP_SORT = 1, XOP_TOPK = 2, XOP_GROUP = 3, XOP_DEDUP = 4, XOP_GATHER = 16, XOP_FIELD = 17, FIELD_MAX = 64, KERNEL_GATHER_FEATURE = "kernel_gather_1", XOP_RECUR = 32, XOP_RECUR_IN = 33, KERNEL_SCAN_FEATURE = "kernel_scan_1", KERNEL_MLP_FEATURE = "kernel_mlp_1", RECUR = {
+  LINEAR_F32: 0,
+  LINEAR_U32: 1,
+  FEEDBACK_F32: 2,
+  PHASE_F64: 3,
+  ADD_F32: 4,
+  MUL_F32: 5,
+  MIN_F32: 6,
+  MAX_F32: 7,
+  ADD_INT: 8,
+  MUL_INT: 9,
+  MIN_I32: 10,
+  MAX_I32: 11,
+  MIN_U32: 12,
+  MAX_U32: 13,
+  AND: 14,
+  OR: 15,
+  XOR: 16
+}, RECUR_KINDS = 17, RECUR_KIND_MASK = 31, RECUR_EXCLUSIVE = 32, RECUR_WIDE = 64;
+function recurSub(sub) {
+  return sub === (32) || sub === (33);
+}
+function recurStateWords(kind) {
+  return kind === RECUR.FEEDBACK_F32 || kind === RECUR.PHASE_F64 ? 2 : 1;
+}
+function recurCoefficient(kind) {
+  return kind <= RECUR.PHASE_F64;
+}
+function recurFloatOutput(kind) {
+  return kind === RECUR.LINEAR_F32 || kind === RECUR.FEEDBACK_F32 || kind === RECUR.PHASE_F64 || kind >= RECUR.ADD_F32 && kind <= RECUR.MAX_F32;
+}
+var XOP_COMPONENTS_GRID = 20480, XOP_REACH_GRID = 20481, XOP_PROPAGATE_GRID = 20482, XOP_COMPONENTS_EDGES = 20483, GRAPH_EMPTY = 4294967295, SORT_KEY_U32 = 0, SORT_KEY_I32 = 1, SORT_KEY_F32 = 2, SORT_KEY_MASK = 3, SORT_DESCENDING = 4, SORT_RADIX_BITS = 8;
+function sortKey(kind, raw) {
+  return kind === (1) ? (raw ^ 2147483648) >>> 0 : kind === (2) ? (raw & 2147483648) !== 0 ? ~raw >>> 0 : (raw | 2147483648) >>> 0 : raw >>> 0;
+}
+function stageEnds(sub) {
+  switch (xopRange(sub)) {
+    case XOP_RANGE.CROSS:
+      return sub >= (1) && sub <= (4) || recurSub(sub);
+    case XOP_RANGE.SYSTEMS:
+      return sub >= (20480) && sub <= (20483);
+    default:
+      return false;
+  }
+}
+function stageEndingOp(op, sub) {
+  return op === (175) && stageEnds(sub);
+}
+
+// src/game/kernel/fmath64.ts
+var fmath64_exports = {};
+chunkJGBCIKJV_js.__export(fmath64_exports, {
+  acos: () => acos2,
+  asin: () => asin2,
+  atan: () => atan3,
+  atan2: () => atan22,
+  cos: () => cos2,
+  exp: () => exp3,
+  log: () => log3,
+  log2: () => log22,
+  pow: () => pow2,
+  scalbn: () => scalbn,
+  sin: () => sin2,
+  tan: () => tan2
+});
+var view = new Float64Array(1), words = new Uint32Array(view.buffer);
+function high(x) {
+  return view[0] = x, words[1];
+}
+function low(x) {
+  return view[0] = x, words[0];
+}
+function fromWords(hi, lo) {
+  return words[1] = hi >>> 0, words[0] = lo >>> 0, view[0];
+}
+function withLow(x, lo) {
+  return view[0] = x, words[0] = lo >>> 0, view[0];
+}
+function withHigh(x, hi) {
+  return view[0] = x, words[1] = hi >>> 0, view[0];
+}
+function twoPow(n) {
+  return fromWords(1023 + n << 20, 0);
+}
+function scalbn(x, n) {
+  if (n > 1023)
+    x *= twoPow(1023), n -= 1023, n > 1023 && (x *= twoPow(1023), n -= 1023, n > 1023 && (n = 1023));
+  else if (n < -1022) {
+    let mul = twoPow(-1022) * twoPow(53), add = 969;
+    x *= mul, n += add, n < -1022 && (x *= mul, n += add, n < -1022 && (n = -1022));
+  }
+  return x * twoPow(n);
+}
+var S1 = -0.16666666666666632, S2 = 0.00833333333332249, S3 = -1984126982985795e-19, S4 = 27557313707070068e-22, S5 = -2.5050760253406863e-8, S6 = 158969099521155e-24;
+function kSin(x, y, iy) {
+  let z = x * x, w = z * z, r = (0.00833333333332249) + z * ((-1984126982985795e-19) + z * (27557313707070068e-22)) + z * w * ((-2.5050760253406863e-8) + z * (158969099521155e-24)), v = z * x;
+  return iy === 0 ? x + v * ((-0.16666666666666632) + z * r) : x - (z * (0.5 * y - v * r) - y - v * (-0.16666666666666632));
+}
+var C1 = 0.0416666666666666, C2 = -0.001388888888887411, C3 = 2480158728947673e-20, C4 = -2.7557314351390663e-7, C5 = 2087572321298175e-24, C6 = -11359647557788195e-27;
+function kCos(x, y) {
+  let z = x * x, w = z * z, r = z * ((0.0416666666666666) + z * ((-0.001388888888887411) + z * (2480158728947673e-20))) + w * w * ((-2.7557314351390663e-7) + z * ((2087572321298175e-24) + z * (-11359647557788195e-27))), hz = 0.5 * z, v = 1 - hz;
+  return v + (1 - v - hz + (z * r - x * y));
+}
+var T = [
+  0.3333333333333341,
+  0.13333333333320124,
+  0.05396825397622605,
+  0.021869488294859542,
+  0.0088632398235993,
+  0.0035920791075913124,
+  0.0014562094543252903,
+  5880412408202641e-19,
+  2464631348184699e-19,
+  7817944429395571e-20,
+  7140724913826082e-20,
+  -18558637485527546e-21,
+  2590730518636337e-20
+], PIO4 = 0.7853981633974483, PIO4_LO = 3061616997868383e-32;
+function zeroLow(x) {
+  return withLow(x, 0);
+}
+function kTan(x, y, odd) {
+  let hx = high(x), big = (hx & 2147483647) >>> 0 >= 1072010280;
+  big && (hx >>> 31 && (x = -x, y = -y), x = (0.7853981633974483) - x + ((3061616997868383e-32) - y), y = 0);
+  let z = x * x, w = z * z, r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11])))), v = z * (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12]))))), s = z * x;
+  r = y + z * (s * (r + v) + y) + s * T[0];
+  let ww = x + r;
+  if (big) {
+    let sign = hx >>> 31, ss = 1 - 2 * odd, vv = ss - 2 * (x + (r - ww * ww / (ww + ss)));
+    return sign !== 0 ? -vv : vv;
+  }
+  if (odd === 0) return ww;
+  let w0 = zeroLow(ww), v0 = r - (w0 - x), a = -1 / ww, a0 = zeroLow(a);
+  return a0 + a * (1 + a0 * w0 + a0 * v0);
+}
+var IPIO2 = [
+  10680707,
+  7228996,
+  1387004,
+  2578385,
+  16069853,
+  12639074,
+  9804092,
+  4427841,
+  16666979,
+  11263675,
+  12935607,
+  2387514,
+  4345298,
+  14681673,
+  3074569,
+  13734428,
+  16653803,
+  1880361,
+  10960616,
+  8533493,
+  3062596,
+  8710556,
+  7349940,
+  6258241,
+  3772886,
+  3769171,
+  3798172,
+  8675211,
+  12450088,
+  3874808,
+  9961438,
+  366607,
+  15675153,
+  9132554,
+  7151469,
+  3571407,
+  2607881,
+  12013382,
+  4155038,
+  6285869,
+  7677882,
+  13102053,
+  15825725,
+  473591,
+  9065106,
+  15363067,
+  6271263,
+  9264392,
+  5636912,
+  4652155,
+  7056368,
+  13614112,
+  10155062,
+  1944035,
+  9527646,
+  15080200,
+  6658437,
+  6231200,
+  6832269,
+  16767104,
+  5075751,
+  3212806,
+  1398474,
+  7579849,
+  6349435,
+  12618859
+], PIO2_PARTS = [
+  1.570796251296997,
+  7549789415861596e-23,
+  5390302529957765e-30,
+  3282003415807913e-37,
+  1270655753080676e-44,
+  12293330898111133e-52,
+  27337005381646456e-60,
+  21674168387780482e-67
+], X1P24 = 16777216, X1P_24 = 1 / 16777216;
+function remPio2Large(x, y, e0) {
+  let nx = x.length, f = new Array(20).fill(0), fq = new Array(20).fill(0), q = new Array(20).fill(0), iq = new Array(20).fill(0), jx = nx - 1, jv = Math.trunc((e0 - 3) / 24);
+  jv < 0 && (jv = 0);
+  let q0 = e0 - 24 * (jv + 1), j = jv - jx, m = jx + 4;
+  for (let i = 0; i <= m; i++)
+    f[i] = j < 0 ? 0 : IPIO2[j], j++;
+  for (let i = 0; i <= 4; i++) {
+    let fw2 = 0;
+    for (let k = 0; k <= jx; k++) fw2 += x[k] * f[jx + i - k];
+    q[i] = fw2;
+  }
+  let jz = 4, z = 0, n = 0, ih = 0;
+  for (; ; ) {
+    let i = 0;
+    z = q[jz];
+    for (let k = jz; k >= 1; k--) {
+      let fw2 = X1P_24 * z | 0;
+      iq[i] = z - (16777216) * fw2 | 0, z = q[k - 1] + fw2, i++;
+    }
+    if (z = scalbn(z, q0), z -= 8 * Math.floor(z * 0.125), n = z | 0, z -= n, ih = 0, q0 > 0 ? (i = iq[jz - 1] >> 24 - q0, n += i, iq[jz - 1] -= i << 24 - q0, ih = iq[jz - 1] >> 23 - q0) : q0 === 0 ? ih = iq[jz - 1] >> 23 : z >= 0.5 && (ih = 2), ih > 0) {
+      n += 1;
+      let carry = 0;
+      for (let k = 0; k < jz; k++) {
+        let v = iq[k];
+        carry === 0 ? v !== 0 && (carry = 1, iq[k] = 16777216 - v) : iq[k] = 16777215 - v;
+      }
+      q0 > 0 && (q0 === 1 ? iq[jz - 1] &= 8388607 : q0 === 2 && (iq[jz - 1] &= 4194303)), ih === 2 && (z = 1 - z, carry !== 0 && (z -= scalbn(1, q0)));
+    }
+    if (z === 0) {
+      let acc2 = 0;
+      for (let k = jz - 1; k >= 4; k--) acc2 |= iq[k];
+      if (acc2 === 0) {
+        let k = 1;
+        for (; iq[4 - k] === 0; ) k++;
+        for (let t = jz + 1; t <= jz + k; t++) {
+          f[jx + t] = IPIO2[jv + t];
+          let fw2 = 0;
+          for (let s = 0; s <= jx; s++) fw2 += x[s] * f[jx + t - s];
+          q[t] = fw2;
+        }
+        jz += k;
+        continue;
+      }
+    }
+    break;
+  }
+  if (z === 0)
+    for (jz -= 1, q0 -= 24; iq[jz] === 0; )
+      jz -= 1, q0 -= 24;
+  else if (z = scalbn(z, -q0), z >= (16777216)) {
+    let fw2 = X1P_24 * z | 0;
+    iq[jz] = z - (16777216) * fw2 | 0, jz += 1, q0 += 24, iq[jz] = fw2;
+  } else
+    iq[jz] = z | 0;
+  let fw = scalbn(1, q0);
+  for (let i = jz; i >= 0; i--)
+    q[i] = fw * iq[i], fw *= X1P_24;
+  for (let i = jz; i >= 0; i--) {
+    let acc2 = 0;
+    for (let k = 0; k <= 4 && k <= jz - i; k++) acc2 += PIO2_PARTS[k] * q[i + k];
+    fq[jz - i] = acc2;
+  }
+  let acc = 0;
+  for (let i = jz; i >= 0; i--) acc += fq[i];
+  y[0] = ih === 0 ? acc : -acc, acc = fq[0] - acc;
+  for (let i = 1; i <= jz; i++) acc += fq[i];
+  return y[1] = ih === 0 ? acc : -acc, n & 7;
+}
+var TO_INT = 1.5 / 2220446049250313e-31, INV_PIO2 = 0.6366197723675814, PIO2_1 = 1.5707963267341256, PIO2_1T = 6077100506506192e-26, PIO2_2 = 6077100506303966e-26, PIO2_2T = 20222662487959506e-37, PIO2_3 = 20222662487111665e-37, PIO2_3T = 84784276603689e-45, reduced = [0, 0];
+function medium(x, ix) {
+  let fn = x * (0.6366197723675814) + TO_INT - TO_INT, n = fn | 0, r = x - fn * (1.5707963267341256), w = fn * (6077100506506192e-26), y0 = r - w, ex = ix >>> 20, ey = high(y0) >>> 20 & 2047;
+  if (ex - ey > 16) {
+    let t = r;
+    w = fn * (6077100506303966e-26), r = t - w, w = fn * (20222662487959506e-37) - (t - r - w), y0 = r - w, ey = high(y0) >>> 20 & 2047, ex - ey > 49 && (t = r, w = fn * (20222662487111665e-37), r = t - w, w = fn * (84784276603689e-45) - (t - r - w), y0 = r - w);
+  }
+  return reduced[0] = y0, reduced[1] = r - y0 - w, n;
+}
+function step(x, sign, k) {
+  if (sign === 0) {
+    let z2 = x - k * (1.5707963267341256), y02 = z2 - k * (6077100506506192e-26);
+    return reduced[0] = y02, reduced[1] = z2 - y02 - k * (6077100506506192e-26), k;
+  }
+  let z = x + k * (1.5707963267341256), y0 = z + k * (6077100506506192e-26);
+  return reduced[0] = y0, reduced[1] = z - y0 + k * (6077100506506192e-26), -k;
+}
+function remPio2(x) {
+  let sign = high(x) >>> 31, ix = (high(x) & 2147483647) >>> 0;
+  if (ix <= 1074752122)
+    return (ix & 1048575) === 598523 ? medium(x, ix) : ix <= 1073928572 ? step(x, sign, 1) : step(x, sign, 2);
+  if (ix <= 1075594811)
+    return ix <= 1075183036 ? ix === 1074977148 ? medium(x, ix) : step(x, sign, 3) : ix === 1075388923 ? medium(x, ix) : step(x, sign, 4);
+  if (ix < 1094263291) return medium(x, ix);
+  if (ix >= 2146435072)
+    return reduced[0] = x - x, reduced[1] = reduced[0], 0;
+  let z = fromWords((high(x) & 1048575 | 1046 << 20) >>> 0, low(x)), tx = [0, 0, 0];
+  for (let i2 = 0; i2 < 2; i2++)
+    tx[i2] = z | 0, z = (z - tx[i2]) * (16777216);
+  tx[2] = z;
+  let i = 2;
+  for (; i !== 0 && tx[i] === 0; ) i--;
+  let ty = [0, 0, 0], n = remPio2Large(tx.slice(0, i + 1), ty, (ix >> 20) - 1046);
+  return sign !== 0 ? (reduced[0] = -ty[0], reduced[1] = -ty[1], -n) : (reduced[0] = ty[0], reduced[1] = ty[1], n);
+}
+function sin2(x) {
+  let ix = (high(x) & 2147483647) >>> 0;
+  if (ix <= 1072243195)
+    return ix < 1045430272 ? x : kSin(x, 0, 0);
+  if (ix >= 2146435072) return x - x;
+  let n = remPio2(x), [y0, y1] = reduced;
+  switch (n & 3) {
+    case 0:
+      return kSin(y0, y1, 1);
+    case 1:
+      return kCos(y0, y1);
+    case 2:
+      return -kSin(y0, y1, 1);
+    default:
+      return -kCos(y0, y1);
+  }
+}
+function cos2(x) {
+  let ix = (high(x) & 2147483647) >>> 0;
+  if (ix <= 1072243195)
+    return ix < 1044816030 && (x | 0) === 0 ? 1 : kCos(x, 0);
+  if (ix >= 2146435072) return x - x;
+  let n = remPio2(x), [y0, y1] = reduced;
+  switch (n & 3) {
+    case 0:
+      return kCos(y0, y1);
+    case 1:
+      return -kSin(y0, y1, 1);
+    case 2:
+      return -kCos(y0, y1);
+    default:
+      return kSin(y0, y1, 1);
+  }
+}
+function tan2(x) {
+  let ix = (high(x) & 2147483647) >>> 0;
+  if (ix <= 1072243195)
+    return ix < 1044381696 ? x : kTan(x, 0, 0);
+  if (ix >= 2146435072) return x - x;
+  let n = remPio2(x);
+  return kTan(reduced[0], reduced[1], n & 1);
+}
+var ATANHI = [0.4636476090008061, 0.7853981633974483, 0.982793723247329, 1.5707963267948966], ATANLO = [22698777452961687e-33, 3061616997868383e-32, 13903311031230998e-33, 6123233995736766e-32], AT = [
+  0.3333333333333293,
+  -0.19999999999876483,
+  0.14285714272503466,
+  -0.11111110405462356,
+  0.09090887133436507,
+  -0.0769187620504483,
+  0.06661073137387531,
+  -0.058335701337905735,
+  0.049768779946159324,
+  -0.036531572744216916,
+  0.016285820115365782
+];
+function atan3(x) {
+  let ix = high(x), sign = ix >>> 31;
+  if (ix = (ix & 2147483647) >>> 0, ix >= 1141899264) {
+    if (Number.isNaN(x)) return x;
+    let z2 = ATANHI[3] + fromWords(0, 58720256);
+    return sign !== 0 ? -z2 : z2;
+  }
+  let id;
+  if (ix < 1071382528) {
+    if (ix < 1044381696) return x;
+    id = -1;
+  } else
+    x = Math.abs(x), ix < 1072889856 ? ix < 1072037888 ? (x = (2 * x - 1) / (2 + x), id = 0) : (x = (x - 1) / (x + 1), id = 1) : ix < 1073971200 ? (x = (x - 1.5) / (1 + 1.5 * x), id = 2) : (x = -1 / x, id = 3);
+  let z = x * x, w = z * z, s1 = z * (AT[0] + w * (AT[2] + w * (AT[4] + w * (AT[6] + w * (AT[8] + w * AT[10]))))), s2 = w * (AT[1] + w * (AT[3] + w * (AT[5] + w * (AT[7] + w * AT[9]))));
+  if (id < 0) return x - x * (s1 + s2);
+  let r = ATANHI[id] - (x * (s1 + s2) - ATANLO[id] - x);
+  return sign !== 0 ? -r : r;
+}
+var PI = 3.141592653589793, PI_LO = 12246467991473532e-32;
+function atan22(y, x) {
+  if (Number.isNaN(x) || Number.isNaN(y)) return x + y;
+  let ix = high(x), lx = low(x), iy = high(y), ly = low(y);
+  if ((ix - 1072693248 >>> 0 | lx) === 0) return atan3(y);
+  let m = iy >>> 31 & 1 | ix >>> 30 & 2;
+  if (ix = (ix & 2147483647) >>> 0, iy = (iy & 2147483647) >>> 0, (iy | ly) === 0)
+    return m === 0 || m === 1 ? y : m === 2 ? (3.141592653589793) : -(3.141592653589793);
+  if ((ix | lx) === 0) return m & 1 ? -(3.141592653589793) / 2 : (3.141592653589793) / 2;
+  if (ix === 2146435072)
+    return iy === 2146435072 ? m === 0 ? (3.141592653589793) / 4 : m === 1 ? -(3.141592653589793) / 4 : m === 2 ? 3 * (3.141592653589793) / 4 : -3 * (3.141592653589793) / 4 : m === 0 ? 0 : m === 1 ? -0 : m === 2 ? (3.141592653589793) : -(3.141592653589793);
+  if (ix + (64 << 20) >>> 0 < iy || iy === 2146435072) return m & 1 ? -(3.141592653589793) / 2 : (3.141592653589793) / 2;
+  let z = m & 2 && iy + (64 << 20) >>> 0 < ix ? 0 : atan3(Math.abs(y / x));
+  return m === 0 ? z : m === 1 ? -z : m === 2 ? (3.141592653589793) - (z - (12246467991473532e-32)) : z - (12246467991473532e-32) - (3.141592653589793);
+}
+var PIO2_HI = 1.5707963267948966, PIO2_LO = 6123233995736766e-32, PS0 = 0.16666666666666666, PS1 = -0.3255658186224009, PS2 = 0.20121253213486293, PS3 = -0.04005553450067941, PS4 = 7915349942898145e-19, PS5 = 3479331075960212e-20, QS1 = -2.403394911734414, QS2 = 2.0209457602335057, QS3 = -0.6882839716054533, QS4 = 0.07703815055590194;
+function ratio(z) {
+  let p = z * ((0.16666666666666666) + z * ((-0.3255658186224009) + z * ((0.20121253213486293) + z * ((-0.04005553450067941) + z * ((7915349942898145e-19) + z * (3479331075960212e-20)))))), q = 1 + z * ((-2.403394911734414) + z * ((2.0209457602335057) + z * ((-0.6882839716054533) + z * (0.07703815055590194))));
+  return p / q;
+}
+function asin2(x) {
+  let hx = high(x), ix = (hx & 2147483647) >>> 0;
+  if (ix >= 1072693248) {
+    let lx = low(x);
+    return (ix - 1072693248 >>> 0 | lx) === 0 ? x * (1.5707963267948966) + fromWords(946864128, 0) : 0 / (x - x);
+  }
+  if (ix < 1071644672)
+    return ix >= 1048576 && ix < 1045430272 ? x : x + x * ratio(x * x);
+  let z = (1 - Math.abs(x)) * 0.5, s = Math.sqrt(z), r = ratio(z), v;
+  if (ix >= 1072640819)
+    v = (1.5707963267948966) - (2 * (s + s * r) - (6123233995736766e-32));
+  else {
+    let f = withLow(s, 0), c = (z - f * f) / (s + f);
+    v = 0.5 * (1.5707963267948966) - (2 * s * r - ((6123233995736766e-32) - 2 * c) - (0.5 * (1.5707963267948966) - 2 * f));
+  }
+  return hx >>> 31 ? -v : v;
+}
+function acos2(x) {
+  let x1p120 = fromWords(946864128, 0), hx = high(x), ix = (hx & 2147483647) >>> 0;
+  if (ix >= 1072693248) {
+    let lx = low(x);
+    return (ix - 1072693248 >>> 0 | lx) === 0 ? hx >>> 31 ? 2 * (1.5707963267948966) + x1p120 : 0 : 0 / (x - x);
+  }
+  if (ix < 1071644672)
+    return ix <= 1012924416 ? (1.5707963267948966) + x1p120 : (1.5707963267948966) - (x - ((6123233995736766e-32) - x * ratio(x * x)));
+  if (hx >>> 31) {
+    let z2 = (1 + x) * 0.5, s2 = Math.sqrt(z2), w2 = ratio(z2) * s2 - (6123233995736766e-32);
+    return 2 * ((1.5707963267948966) - (s2 + w2));
+  }
+  let z = (1 - x) * 0.5, s = Math.sqrt(z), df = withLow(s, 0), c = (z - df * df) / (s + df), w = ratio(z) * s + c;
+  return 2 * (df + w);
+}
+var LN2HI = 0.6931471803691238, LN2LO = 19082149292705877e-26, INVLN2 = 1.4426950408889634, P1 = 0.16666666666666602, P2 = -0.0027777777777015593, P3 = 6613756321437934e-20, P4 = -16533902205465252e-22, P5 = 41381367970572385e-24;
+function exp3(x) {
+  let x1p1023 = fromWords(2145386496, 0), hx = high(x), sign = hx >>> 31;
+  if (hx = (hx & 2147483647) >>> 0, hx >= 1082532651) {
+    if (Number.isNaN(x)) return x;
+    if (x > 709.782712893384) return x * x1p1023;
+    if (x < -708.3964185322641 && x < -745.1332191019411) return 0;
+  }
+  let k, hi, lo;
+  if (hx > 1071001154)
+    hx >= 1072734898 ? k = (1.4426950408889634) * x + (sign === 0 ? 0.5 : -0.5) | 0 : k = 1 - sign - sign, hi = x - k * (0.6931471803691238), lo = k * (19082149292705877e-26), x = hi - lo;
+  else if (hx > 1043333120)
+    k = 0, hi = x, lo = 0;
+  else
+    return 1 + x;
+  let xx = x * x, c = x - xx * ((0.16666666666666602) + xx * ((-0.0027777777777015593) + xx * ((6613756321437934e-20) + xx * ((-16533902205465252e-22) + xx * (41381367970572385e-24))))), y = 1 + (x * c / (2 - c) - lo + hi);
+  return k === 0 ? y : scalbn(y, k);
+}
+var LG1 = 0.6666666666666735, LG2 = 0.3999999999940942, LG3 = 0.2857142874366239, LG4 = 0.22222198432149784, LG5 = 0.1818357216161805, LG6 = 0.15313837699209373, LG7 = 0.14798198605116586, X1P54 = 18014398509481984;
+function reduceLog(x) {
+  let hx = high(x), k = 0;
+  if (hx < 1048576 || hx >>> 31) {
+    if (x === 0) return -1 / (x * x);
+    if (hx >>> 31) return (x - x) / 0;
+    k -= 54, x *= (18014398509481984), hx = high(x);
+  } else {
+    if (hx >= 2146435072)
+      return x;
+    if (hx === 1072693248 && low(x) === 0)
+      return 0;
+  }
+  return hx = hx + 614242 >>> 0, k += (hx >>> 20) - 1023, hx = (hx & 1048575) + 1072079006 >>> 0, { f: withHigh(x, hx) - 1, k };
+}
+function log3(x) {
+  let red = reduceLog(x);
+  if (typeof red == "number") return red;
+  let { f, k } = red, hfsq = 0.5 * f * f, s = f / (2 + f), z = s * s, w = z * z, t1 = w * ((0.3999999999940942) + w * ((0.22222198432149784) + w * (0.15313837699209373))), r = z * ((0.6666666666666735) + w * ((0.2857142874366239) + w * ((0.1818357216161805) + w * (0.14798198605116586)))) + t1, dk = k;
+  return s * (hfsq + r) + dk * (19082149292705877e-26) - hfsq + f + dk * (0.6931471803691238);
+}
+var IVLN2HI = 1.4426950407214463, IVLN2LO = 16751713164886512e-26;
+function log22(x) {
+  let red = reduceLog(x);
+  if (typeof red == "number") return red;
+  let { f, k } = red, hfsq = 0.5 * f * f, s = f / (2 + f), z = s * s, w = z * z, t1 = w * ((0.3999999999940942) + w * ((0.22222198432149784) + w * (0.15313837699209373))), r = z * ((0.6666666666666735) + w * ((0.2857142874366239) + w * ((0.1818357216161805) + w * (0.14798198605116586)))) + t1, hi = withLow(f - hfsq, 0), lo = f - hi - hfsq + s * (hfsq + r), valHi = hi * (1.4426950407214463), valLo = (lo + hi) * (16751713164886512e-26) + lo * (1.4426950407214463), y = k;
+  return w = y + valHi, valLo += y - w + valHi, valHi = w, valLo + valHi;
+}
+var BP = [1, 1.5], DP_H = [0, 0.5849624872207642], DP_L = [0, 1350039202129749e-23], TWO53 = 9007199254740992, HUGE = 1e300, TINY = 1e-300, L1 = 0.5999999999999946, L2 = 0.4285714285785502, L3 = 0.33333332981837743, L4 = 0.272728123808534, L5 = 0.23066074577556175, L6 = 0.20697501780033842, LG2F = 0.6931471805599453, LG2_H = 0.6931471824645996, LG2_L = -1.904654299957768e-9, OVT = 8008566259537294e-32, CP = 0.9617966939259756, CP_H = 0.9617967009544373, CP_L = -7.028461650952758e-9, IVLN2 = 1.4426950408889634, IVLN2_H = 1.4426950216293335, IVLN2_L = 19259629911266175e-24;
+function pow2(x, y) {
+  let hx = high(x) | 0, lx = low(x), hy = high(y) | 0, ly = low(y), ix = hx & 2147483647, iy = hy & 2147483647;
+  if ((iy | ly) === 0 || hx === 1072693248 && lx === 0) return 1;
+  if (ix > 2146435072 || ix === 2146435072 && lx !== 0 || iy > 2146435072 || iy === 2146435072 && ly !== 0) return x + y;
+  let yisint = 0, k, j;
+  if (hx < 0 && (iy >= 1128267776 ? yisint = 2 : iy >= 1072693248 && (k = (iy >> 20) - 1023, k > 20 ? (j = ly >>> 52 - k | 0, j << 52 - k === (ly | 0) && (yisint = 2 - (j & 1))) : ly === 0 && (j = iy >> 20 - k, j << 20 - k === iy && (yisint = 2 - (j & 1))))), ly === 0) {
+    if (iy === 2146435072)
+      return (ix - 1072693248 | lx) === 0 ? 1 : ix >= 1072693248 ? hy >= 0 ? y : 0 : hy >= 0 ? 0 : -y;
+    if (iy === 1072693248) return hy >= 0 ? x : 1 / x;
+    if (hy === 1073741824) return x * x;
+    if (hy === 1071644672 && hx >= 0) return Math.sqrt(x);
+  }
+  let ax = Math.abs(x);
+  if (lx === 0 && (ix === 2146435072 || ix === 0 || ix === 1072693248)) {
+    let z2 = ax;
+    return hy < 0 && (z2 = 1 / z2), hx < 0 && ((ix - 1072693248 | yisint) === 0 ? z2 = (z2 - z2) / (z2 - z2) : yisint === 1 && (z2 = -z2)), z2;
+  }
+  let s = 1;
+  if (hx < 0) {
+    if (yisint === 0) return (x - x) / (x - x);
+    yisint === 1 && (s = -1);
+  }
+  let t1, t2;
+  if (iy > 1105199104) {
+    if (iy > 1139802112) {
+      if (ix <= 1072693247) return hy < 0 ? (1e300) * (1e300) : (1e-300) * (1e-300);
+      if (ix >= 1072693248) return hy > 0 ? (1e300) * (1e300) : (1e-300) * (1e-300);
+    }
+    if (ix < 1072693247) return hy < 0 ? s * (1e300) * (1e300) : s * (1e-300) * (1e-300);
+    if (ix > 1072693248) return hy > 0 ? s * (1e300) * (1e300) : s * (1e-300) * (1e-300);
+    let t3 = ax - 1, w2 = t3 * t3 * (0.5 - t3 * (0.3333333333333333 - t3 * 0.25)), u2 = (1.4426950216293335) * t3, v2 = t3 * (19259629911266175e-24) - w2 * (1.4426950408889634);
+    t1 = withLow(u2 + v2, 0), t2 = v2 - (t1 - u2);
+  } else {
+    let n2 = 0;
+    ix < 1048576 && (ax *= (9007199254740992), n2 -= 53, ix = high(ax) | 0), n2 += (ix >> 20) - 1023, j = ix & 1048575;
+    let kk;
+    ix = j | 1072693248, j <= 235662 ? kk = 0 : j < 767610 ? kk = 1 : (kk = 0, n2 += 1, ix -= 1048576), ax = withHigh(ax, ix >>> 0);
+    let u2 = ax - BP[kk], v2 = 1 / (ax + BP[kk]), ss = u2 * v2, sH = withLow(ss, 0), tH = fromWords((ix >>> 1 | 536870912) + 524288 + (kk << 18) >>> 0, 0), tL = ax - (tH - BP[kk]), sL = v2 * (u2 - sH * tH - sH * tL), s2 = ss * ss, r2 = s2 * s2 * ((0.5999999999999946) + s2 * ((0.4285714285785502) + s2 * ((0.33333332981837743) + s2 * ((0.272728123808534) + s2 * ((0.23066074577556175) + s2 * (0.20697501780033842))))));
+    r2 += sL * (sH + ss), s2 = sH * sH, tH = withLow(3 + s2 + r2, 0), tL = r2 - (tH - 3 - s2);
+    let uu = sH * tH, vv = sL * tH + tL * ss, pH2 = withLow(uu + vv, 0), pL2 = vv - (pH2 - uu), zH = (0.9617967009544373) * pH2, zL = (-7.028461650952758e-9) * pH2 + pL2 * (0.9617966939259756) + DP_L[kk], t3 = n2;
+    t1 = withLow(zH + zL + DP_H[kk] + t3, 0), t2 = zL - (t1 - t3 - DP_H[kk] - zH);
+  }
+  let y1 = withLow(y, 0), pL = (y - y1) * t1 + y * t2, pH = y1 * t1, z = pL + pH, jj = high(z) | 0, ii = low(z) | 0;
+  if (jj >= 1083179008) {
+    if ((jj - 1083179008 | ii) !== 0 || pL + (8008566259537294e-32) > z - pH) return s * (1e300) * (1e300);
+  } else if ((jj & 2147483647) >= 1083231232 && (((jj >>> 0) - 3230714880 | ii) !== 0 || pL <= z - pH))
+    return s * (1e-300) * (1e-300);
+  let i = jj & 2147483647;
+  k = (i >> 20) - 1023;
+  let n = 0;
+  if (i > 1071644672) {
+    n = jj + (1048576 >> k + 1) | 0, k = ((n & 2147483647) >> 20) - 1023;
+    let t3 = fromWords((n & ~(1048575 >> k)) >>> 0, 0);
+    n = (n & 1048575 | 1048576) >> 20 - k, jj < 0 && (n = -n), pH -= t3;
+  }
+  let t = withLow(pL + pH, 0), u = t * (0.6931471824645996), v = (pL - (t - pH)) * (0.6931471805599453) + t * (-1.904654299957768e-9);
+  z = u + v;
+  let w = v - (z - u), tt = z * z, tt1 = z - tt * ((0.16666666666666602) + tt * ((-0.0027777777777015593) + tt * ((6613756321437934e-20) + tt * ((-16533902205465252e-22) + tt * (41381367970572385e-24)))));
+  return z = 1 - (z * tt1 / (tt1 - 2) - (w + z * w) - z), jj = high(z) | 0, jj = jj + (n << 20) | 0, jj >> 20 <= 0 ? z = scalbn(z, n) : z = withHigh(z, jj >>> 0), s * z;
+}
+
+// src/game/kernel/lanes.ts
+var lanes_exports = {};
+chunkJGBCIKJV_js.__export(lanes_exports, {
+  CANONICAL_NAN32: () => (2143289344),
+  INSERT_WIDTH_SHIFT: () => (8),
+  LANE_OP: () => LANE_OP,
+  evalLane: () => evalLane,
+  joinF64: () => joinF64,
+  joinU64: () => joinU64,
+  laneSignature: () => laneSignature,
+  runLanes: () => runLanes,
+  toUint32: () => toUint32,
+  toUint64: () => toUint64
+});
+var LANE_OP = {
+  F64_ADD: 8192,
+  F64_SUB: 8193,
+  F64_MUL: 8194,
+  F64_DIV: 8195,
+  F64_MIN: 8196,
+  F64_MAX: 8197,
+  F64_MOD: 8198,
+  F64_POW: 8199,
+  F64_ATAN2: 8200,
+  F64_NEG: 8208,
+  F64_ABS: 8209,
+  F64_SQRT: 8210,
+  F64_FLOOR: 8211,
+  F64_CEIL: 8212,
+  F64_ROUND: 8213,
+  F64_TRUNC: 8214,
+  F64_SIGN: 8215,
+  F64_SIN: 8216,
+  F64_COS: 8217,
+  F64_TAN: 8218,
+  F64_ASIN: 8219,
+  F64_ACOS: 8220,
+  F64_ATAN: 8221,
+  F64_EXP: 8222,
+  F64_LOG: 8223,
+  F64_LOG2: 8224,
+  F64_LT: 8240,
+  F64_LE: 8241,
+  F64_EQ: 8242,
+  F64_NE: 8243,
+  F64_FROM_F32: 8256,
+  F64_FROM_I32: 8257,
+  F64_FROM_U32: 8258,
+  F64_TO_F32: 8259,
+  F64_TO_I32: 8260,
+  F64_TO_U32: 8261,
+  F64_FROM_U64: 8262,
+  F64_TO_U64: 8263,
+  BIT_POPCNT: 8448,
+  BIT_CLZ: 8449,
+  BIT_CTZ: 8450,
+  BIT_ROTL: 8451,
+  BIT_ROTR: 8452,
+  BIT_EXTRACT: 8453,
+  BIT_INSERT: 8454,
+  BIT_MORTON2: 8455,
+  BIT_MORTON3: 8456,
+  BIT_UNMORTON2: 8457,
+  BIT_UNMORTON3: 8458,
+  BIT64_POPCNT: 8464,
+  BIT64_CLZ: 8465,
+  BIT64_CTZ: 8466,
+  BIT64_ROTL: 8467,
+  BIT64_ROTR: 8468,
+  BIT64_EXTRACT: 8469,
+  BIT64_INSERT: 8470,
+  BIT64_MORTON2: 8471,
+  BIT64_MORTON3: 8472,
+  BIT64_UNMORTON2: 8473,
+  BIT64_UNMORTON3: 8474,
+  U64_SHL: 8480,
+  U64_SHR: 8481,
+  U64_MUL: 8482,
+  U64_DIV: 8483,
+  U64_REM: 8484
+}, INSERT_WIDTH_SHIFT = 8, CANONICAL_NAN32 = 2143289344, L = LANE_OP, A = 1, B = 2, C = 4, EA = 8, EB = 16, PAIR = (1) | (2), PAIRS = (1) | (2) | (4) | (8), TWO32 = 4294967296, TWO64 = 18446744073709552e3, MASK64 = (1n << 64n) - 1n;
+function laneSignature(sub) {
+  if (sub >= L.F64_ADD && sub <= L.F64_ATAN2 || sub >= L.U64_MUL && sub <= L.U64_REM) return [PAIRS, 2];
+  if (sub === L.U64_SHL || sub === L.U64_SHR) return [PAIR | (4), 2];
+  if (sub >= L.F64_NEG && sub <= L.F64_LOG2 || sub === L.F64_FROM_U64 || sub === L.F64_TO_U64) return [PAIR, 2];
+  if (sub >= L.F64_LT && sub <= L.F64_NE) return [PAIRS, 1];
+  if (sub >= L.F64_FROM_F32 && sub <= L.F64_FROM_U32) return [(1), 2];
+  if (sub >= L.F64_TO_F32 && sub <= L.F64_TO_U32) return [PAIR, 1];
+  switch (sub) {
+    case L.BIT_POPCNT:
+    case L.BIT_CLZ:
+    case L.BIT_CTZ:
+      return [(1), 1];
+    case L.BIT_ROTL:
+    case L.BIT_ROTR:
+    case L.BIT_MORTON2:
+      return [(1) | (2), 1];
+    case L.BIT_EXTRACT:
+    case L.BIT_MORTON3:
+      return [(1) | (2) | (4), 1];
+    case L.BIT_INSERT:
+      return [(1) | (2) | (4) | (8), 1];
+    case L.BIT_UNMORTON2:
+      return [(1), 2];
+    case L.BIT_UNMORTON3:
+      return [(1), 3];
+    case L.BIT64_POPCNT:
+    case L.BIT64_CLZ:
+    case L.BIT64_CTZ:
+      return [PAIR, 1];
+    case L.BIT64_ROTL:
+    case L.BIT64_ROTR:
+    case L.BIT64_MORTON3:
+      return [PAIR | (4), 2];
+    case L.BIT64_EXTRACT:
+      return [PAIRS, 2];
+    case L.BIT64_INSERT:
+      return [PAIRS | (16), 2];
+    case L.BIT64_MORTON2:
+    case L.BIT64_UNMORTON2:
+      return [PAIR, 2];
+    case L.BIT64_UNMORTON3:
+      return [PAIR, 3];
+    default:
+      return null;
+  }
+}
+var view2 = new Float64Array(1), halves = new Uint32Array(view2.buffer), f322 = new Float32Array(1), f32bits = new Uint32Array(f322.buffer);
+function joinF64(lo, hi) {
+  return halves[0] = lo >>> 0, halves[1] = hi >>> 0, view2[0];
+}
+function splitF64(x, out) {
+  if (Number.isNaN(x)) {
+    out[0] = 0, out[1] = 2146959360;
+    return;
+  }
+  view2[0] = x, out[0] = halves[0], out[1] = halves[1];
+}
+function joinU64(lo, hi) {
+  return BigInt(hi >>> 0) << 32n | BigInt(lo >>> 0);
+}
+function splitU64(v, out) {
+  let w = v & MASK64;
+  out[0] = Number(w & 0xffffffffn), out[1] = Number(w >> 32n);
+}
+function jsMin(x, y) {
+  return Number.isNaN(x) || Number.isNaN(y) ? Number.NaN : x === y ? Object.is(x, -0) || Object.is(y, -0) ? -0 : x : x < y ? x : y;
+}
+function jsMax(x, y) {
+  return Number.isNaN(x) || Number.isNaN(y) ? Number.NaN : x === y ? Object.is(x, 0) || Object.is(y, 0) ? 0 : x : x > y ? x : y;
+}
+function jsPow(x, y) {
+  return Number.isNaN(y) || Math.abs(x) === 1 && !Number.isFinite(y) ? Number.NaN : pow2(x, y);
+}
+function jsRound(x) {
+  if (!Number.isFinite(x) || x === 0) return x;
+  let r = Math.floor(x), v = x - r >= 0.5 ? r + 1 : r;
+  return v === 0 && x < 0 ? -0 : v;
+}
+function jsSign(x) {
+  return x > 0 ? 1 : x < 0 ? -1 : x;
+}
+function toUint32(x) {
+  if (!Number.isFinite(x)) return 0;
+  let m = Math.trunc(x) % (4294967296);
+  return (m < 0 ? m + (4294967296) : m) >>> 0;
+}
+function toUint64(x) {
+  if (!Number.isFinite(x)) return 0n;
+  let t = Math.trunc(x), q = BigInt(Math.abs(t) % (18446744073709552e3));
+  return t < 0 ? -q & MASK64 : q;
+}
+function binary64(sub, x, y) {
+  switch (sub) {
+    case L.F64_ADD:
+      return x + y;
+    case L.F64_SUB:
+      return x - y;
+    case L.F64_MUL:
+      return x * y;
+    case L.F64_DIV:
+      return x / y;
+    case L.F64_MIN:
+      return jsMin(x, y);
+    case L.F64_MAX:
+      return jsMax(x, y);
+    case L.F64_MOD:
+      return x % y;
+    case L.F64_POW:
+      return jsPow(x, y);
+    default:
+      return atan22(x, y);
+  }
+}
+function unary64(sub, x) {
+  switch (sub) {
+    case L.F64_NEG:
+      return -x;
+    case L.F64_ABS:
+      return Math.abs(x);
+    case L.F64_SQRT:
+      return Math.sqrt(x);
+    case L.F64_FLOOR:
+      return Math.floor(x);
+    case L.F64_CEIL:
+      return Math.ceil(x);
+    case L.F64_ROUND:
+      return jsRound(x);
+    case L.F64_TRUNC:
+      return Math.trunc(x);
+    case L.F64_SIGN:
+      return jsSign(x);
+    case L.F64_SIN:
+      return sin2(x);
+    case L.F64_COS:
+      return cos2(x);
+    case L.F64_TAN:
+      return tan2(x);
+    case L.F64_ASIN:
+      return asin2(x);
+    case L.F64_ACOS:
+      return acos2(x);
+    case L.F64_ATAN:
+      return atan3(x);
+    case L.F64_EXP:
+      return exp3(x);
+    case L.F64_LOG:
+      return log3(x);
+    default:
+      return log22(x);
+  }
+}
+function ones(width, bits) {
+  return width >= bits ? (1n << BigInt(bits)) - 1n : (1n << BigInt(width)) - 1n;
+}
+function extract(a, offset, width, bits) {
+  return a >> BigInt(offset & bits - 1) & ones(width >>> 0, bits);
+}
+function insert(base, value, offset, width, bits) {
+  let at = BigInt(offset & bits - 1), field = ones(width >>> 0, bits) << at;
+  return (base & ~field | value << at & field) & ones(bits, bits);
+}
+function spread(v, bits, step2) {
+  let out = 0n;
+  for (let k = 0; k < bits; k++) out |= (v >> BigInt(k) & 1n) << BigInt(k * step2);
+  return out;
+}
+function gather(v, bits, step2, at) {
+  let out = 0n;
+  for (let k = 0; k < bits; k++) out |= (v >> BigInt(k * step2 + at) & 1n) << BigInt(k);
+  return out;
+}
+function popcount(v) {
+  let n = 0;
+  for (; v > 0n; )
+    n += Number(v & 1n), v >>= 1n;
+  return n;
+}
+function clz(v, bits) {
+  let n = 0;
+  for (let k = bits - 1; k >= 0 && (v >> BigInt(k) & 1n) === 0n; k--) n++;
+  return n;
+}
+function ctz(v, bits) {
+  let n = 0;
+  for (let k = 0; k < bits && (v >> BigInt(k) & 1n) === 0n; k++) n++;
+  return n;
+}
+function rotl(v, s, bits) {
+  let n = BigInt(s & bits - 1), mask = ones(bits, bits);
+  return (v << n | v >> BigInt(bits) - n) & mask;
+}
+function wide64(sub, x, y) {
+  switch (sub) {
+    case L.U64_SHL:
+      return x << (y & 63n) & MASK64;
+    case L.U64_SHR:
+      return x >> (y & 63n);
+    case L.U64_MUL:
+      return x * y & MASK64;
+    case L.U64_DIV:
+      return y === 0n ? 0n : x / y;
+    default:
+      return y === 0n ? 0n : x % y;
+  }
+}
+var laneIn = new Uint32Array(5), laneOut = new Uint32Array(3);
+function runLanes(sub, inputs, targets, n, read, write) {
+  let signature = laneSignature(sub);
+  if (signature === null) return;
+  let [mask, outputs] = signature;
+  for (let k = 0; k < n; k++) {
+    for (let w = 0; w < 5; w++) laneIn[w] = mask & 1 << w ? read(inputs[w], k) : 0;
+    evalLane(sub, laneIn, laneOut);
+    for (let o = 0; o < outputs; o++) write(targets[o], k, laneOut[o]);
+  }
+}
+function evalLane(sub, v, out) {
+  out[0] = 0, out[1] = 0, out[2] = 0;
+  let word = (r) => {
+    out[0] = Number(r) >>> 0;
+  };
+  if (sub >= L.F64_ADD && sub <= L.F64_ATAN2) return splitF64(binary64(sub, joinF64(v[0], v[1]), joinF64(v[2], v[3])), out);
+  if (sub >= L.U64_MUL && sub <= L.U64_REM) return splitU64(wide64(sub, joinU64(v[0], v[1]), joinU64(v[2], v[3])), out);
+  if (sub === L.U64_SHL || sub === L.U64_SHR) return splitU64(wide64(sub, joinU64(v[0], v[1]), BigInt(v[2])), out);
+  if (sub >= L.F64_NEG && sub <= L.F64_LOG2) return splitF64(unary64(sub, joinF64(v[0], v[1])), out);
+  if (sub === L.F64_FROM_U64) return splitF64(v[1] * (4294967296) + v[0], out);
+  if (sub === L.F64_TO_U64) return splitU64(toUint64(joinF64(v[0], v[1])), out);
+  if (sub >= L.F64_LT && sub <= L.F64_NE) {
+    let x2 = joinF64(v[0], v[1]), y2 = joinF64(v[2], v[3]), t = sub === L.F64_LT ? x2 < y2 : sub === L.F64_LE ? x2 <= y2 : sub === L.F64_EQ ? x2 === y2 : x2 !== y2;
+    out[0] = t ? 4294967295 : 0;
+    return;
+  }
+  if (sub === L.F64_FROM_F32)
+    return f32bits[0] = v[0], splitF64(f322[0], out);
+  if (sub === L.F64_FROM_I32) return splitF64(v[0] | 0, out);
+  if (sub === L.F64_FROM_U32) return splitF64(v[0] >>> 0, out);
+  if (sub === L.F64_TO_F32) {
+    let x2 = Math.fround(joinF64(v[0], v[1]));
+    Number.isNaN(x2) ? out[0] = (2143289344) : (f322[0] = x2, out[0] = f32bits[0]);
+    return;
+  }
+  if (sub === L.F64_TO_I32 || sub === L.F64_TO_U32) return word(toUint32(joinF64(v[0], v[1])));
+  let a = BigInt(v[0]), b = BigInt(v[1]), c = BigInt(v[2]), x = joinU64(v[0], v[1]), y = joinU64(v[2], v[3]);
+  switch (sub) {
+    case L.BIT_POPCNT:
+      return word(popcount(a));
+    case L.BIT_CLZ:
+      return word(clz(a, 32));
+    case L.BIT_CTZ:
+      return word(ctz(a, 32));
+    case L.BIT_ROTL:
+      return word(rotl(a, v[1], 32));
+    case L.BIT_ROTR:
+      return word(rotl(a, 32 - (v[1] & 31) & 31, 32));
+    case L.BIT_EXTRACT:
+      return word(extract(a, v[1], v[2], 32));
+    case L.BIT_INSERT:
+      return word(insert(a, b, v[2], v[3], 32));
+    case L.BIT_MORTON2:
+      return word(spread(a, 16, 2) | spread(b, 16, 2) << 1n);
+    case L.BIT_MORTON3:
+      return word(spread(a, 10, 3) | spread(b, 10, 3) << 1n | spread(c, 10, 3) << 2n);
+    case L.BIT_UNMORTON2:
+      out[0] = Number(gather(a, 16, 2, 0)), out[1] = Number(gather(a, 16, 2, 1));
+      return;
+    case L.BIT_UNMORTON3:
+      out[0] = Number(gather(a, 10, 3, 0)), out[2] = Number(gather(a, 10, 3, 1)), out[1] = Number(gather(a, 10, 3, 2));
+      return;
+    case L.BIT64_POPCNT:
+      return word(popcount(x));
+    case L.BIT64_CLZ:
+      return word(clz(x, 64));
+    case L.BIT64_CTZ:
+      return word(ctz(x, 64));
+    case L.BIT64_ROTL:
+      return splitU64(rotl(x, v[2], 64), out);
+    case L.BIT64_ROTR:
+      return splitU64(rotl(x, 64 - (v[2] & 63) & 63, 64), out);
+    case L.BIT64_EXTRACT:
+      return splitU64(extract(x, v[2], v[3], 64), out);
+    case L.BIT64_INSERT:
+      return splitU64(insert(x, y, v[4] & 255, v[4] >>> (8), 64), out);
+    case L.BIT64_MORTON2:
+      return splitU64(spread(a, 32, 2) | spread(b, 32, 2) << 1n, out);
+    case L.BIT64_MORTON3:
+      return splitU64(spread(a, 21, 3) | spread(b, 21, 3) << 1n | spread(c, 21, 3) << 2n, out);
+    case L.BIT64_UNMORTON2:
+      out[0] = Number(gather(x, 32, 2, 0)), out[1] = Number(gather(x, 32, 2, 1));
+      return;
+    case L.BIT64_UNMORTON3:
+      out[0] = Number(gather(x, 21, 3, 0)), out[2] = Number(gather(x, 21, 3, 1)), out[1] = Number(gather(x, 21, 3, 2));
+      return;
+  }
+}
+
+// src/game/kernel/data.ts
+var TRUE = 4294967295, MIN_SLOTS = 16, FNV_OFFSET = 2166136261, FNV_PRIME = 16777619, COMMAND_WORDS = 4, DEFAULT_COMMANDS = 8192, DEFAULT_PICKS = 256, STORAGE_F32 = 0, STORAGE_I32 = 1, STORAGE_U32 = 2;
+function symbol(name) {
+  let bytes = new TextEncoder().encode(name), hash = (2166136261);
+  for (let byte of bytes) hash = Math.imul(hash ^ byte, (16777619)) >>> 0;
+  return hash >>> 0;
+}
+function mix(value) {
+  let x = value >>> 0;
+  return x ^= x >>> 16, x = Math.imul(x, 2146121005), x ^= x >>> 15, x = Math.imul(x, 2221713035), (x ^ x >>> 16) >>> 0;
+}
+function tableOf(word) {
+  return word >>> (19) & (15);
+}
+function isPool(word) {
+  return (word & ACCESS_POOL) !== 0;
+}
+function readAs(kind, storage, raw) {
+  return kind === 0 ? storage === (0) ? f32Bits(raw) : f32Bits(Math.fround(storage === (1) ? raw | 0 : raw >>> 0)) : kind === 3 ? raw !== 0 && !Number.isNaN(raw) ? (4294967295) : 0 : storage === (0) ? (raw | 0) >>> 0 : raw >>> 0;
+}
+function writeAs(kind, storage, value) {
+  return storage === (0) ? kind === 0 ? f32From(value) : kind === 3 ? value !== 0 ? 1 : 0 : Math.fround(kind === 1 ? value | 0 : value >>> 0) : kind === 0 ? f32From(value) | 0 : kind === 3 ? value !== 0 ? 1 : 0 : value;
+}
+function sameColumn(p, q) {
+  return p.values === q.values || p.values.buffer === q.values.buffer && p.values.byteOffset === q.values.byteOffset && p.values.length > 0;
+}
+function exact(kind, storage) {
+  return kind === 0 ? storage === (0) : kind === 1 || kind === 2 ? storage === (1) || storage === (2) : false;
+}
+function fmin(a, b) {
+  return a < b ? a : b < a ? b : Number.isNaN(a) ? a : b;
+}
+function fmax(a, b) {
+  return a > b ? a : b > a ? b : Number.isNaN(a) ? a : b;
+}
+function command(mode, current, value) {
+  let f = f32From, b = f32Bits;
+  switch (mode) {
+    case SEND.FADD:
+      return b(Math.fround(f(current) + f(value)));
+    case SEND.FMUL:
+      return b(Math.fround(f(current) * f(value)));
+    case SEND.FMIN:
+      return b(fmin(f(current), f(value)));
+    case SEND.FMAX:
+      return b(fmax(f(current), f(value)));
+    case SEND.IADD:
+      return current + value >>> 0;
+    case SEND.IMIN:
+      return Math.min(current | 0, value | 0) >>> 0;
+    case SEND.IMAX:
+      return Math.max(current | 0, value | 0) >>> 0;
+    case SEND.UMIN:
+      return Math.min(current >>> 0, value >>> 0);
+    case SEND.UMAX:
+      return Math.max(current >>> 0, value >>> 0);
+    case SEND.OR:
+      return (current | value) >>> 0;
+    case SEND.AND:
+      return (current & value) >>> 0;
+    default:
+      return value >>> 0;
+  }
+}
+function pickOrder(mode, key) {
+  return mode === (0) ? key >>> 0 : Number.isNaN(f32From(key)) ? 4294967295 : sortKey((2), key);
+}
+var KeyIndex = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.epoch = 0;
+    let slots = (16);
+    for (; slots < capacity * 2; ) slots *= 2;
+    this.keys = new Uint32Array(slots), this.rows = new Uint32Array(slots), this.stamps = new Uint32Array(slots), this.mask = slots - 1;
+  }
+  build(count, key) {
+    this.epoch = this.epoch + 1 >>> 0, this.epoch === 0 && (this.stamps.fill(0), this.epoch = 1);
+    let n = Math.min(count, this.capacity);
+    for (let row = 0; row < n; row++) {
+      let k = key(row) >>> 0;
+      if (k === 4294967295) continue;
+      let h = mix(k) & this.mask;
+      for (; ; ) {
+        if (this.stamps[h] !== this.epoch) {
+          this.stamps[h] = this.epoch, this.keys[h] = k, this.rows[h] = row;
+          break;
+        }
+        if (this.keys[h] === k) break;
+        h = h + 1 & this.mask;
+      }
+    }
+  }
+  find(key) {
+    let k = key >>> 0;
+    if (k === 4294967295) return 4294967295;
+    let h = mix(k) & this.mask;
+    for (; ; ) {
+      if (this.stamps[h] !== this.epoch) return 4294967295;
+      if (this.keys[h] === k) return this.rows[h];
+      h = h + 1 & this.mask;
+    }
+  }
+}, Keep = class {
+  constructor(capacity, words2) {
+    this.capacity = capacity;
+    this.words = words2;
+    this.len = 0;
+    this.dropped = 0;
+    this.heaped = false;
+    this.a = new Float64Array(capacity), this.b = new Float64Array(capacity), this.c = new Float64Array(capacity), this.data = new Uint32Array(capacity * words2), this.heap = new Uint32Array(capacity);
+  }
+  clear() {
+    this.len = 0, this.dropped = 0, this.heaped = false;
+  }
+  compare(p, q) {
+    return this.a[p] - this.a[q] || this.b[p] - this.b[q] || this.c[p] - this.c[q];
+  }
+  below(a, b, c, slot) {
+    return a !== this.a[slot] ? a < this.a[slot] : b !== this.b[slot] ? b < this.b[slot] : c < this.c[slot];
+  }
+  siftDown(start) {
+    let n = this.heap.length, at = start;
+    for (; ; ) {
+      let left = 2 * at + 1, right = left + 1, top = at;
+      if (left < n && this.compare(this.heap[left], this.heap[top]) > 0 && (top = left), right < n && this.compare(this.heap[right], this.heap[top]) > 0 && (top = right), top === at) return;
+      let t = this.heap[at];
+      this.heap[at] = this.heap[top], this.heap[top] = t, at = top;
+    }
+  }
+  insert(a, b, c, payload) {
+    let slot;
+    if (this.len < this.capacity)
+      slot = this.len++;
+    else {
+      if (this.dropped++, this.capacity === 0) return;
+      if (!this.heaped) {
+        for (let k = 0; k < this.capacity; k++) this.heap[k] = k;
+        for (let at = (this.capacity >> 1) - 1; at >= 0; at--) this.siftDown(at);
+        this.heaped = true;
+      }
+      let top = this.heap[0];
+      if (!this.below(a, b, c, top)) return;
+      slot = top;
+    }
+    if (this.a[slot] = a, this.b[slot] = b, this.c[slot] = c, payload !== null) for (let w = 0; w < this.words; w++) this.data[slot * this.words + w] = payload[w];
+    this.heaped && this.siftDown(0);
+  }
+}, ListSweep = class {
+  constructor(at, len, table, k) {
+    this.at = at;
+    this.len = len;
+    this.table = table;
+    this.k = k;
+    this.used = new Uint8Array(0);
+    this.blocks = 0;
+    this.unplaced = 0;
+  }
+  bind(blocks) {
+    this.blocks = blocks, this.used = new Uint8Array(blocks);
+  }
+  run(at, len, lenKind, count) {
+    this.used.fill(0), this.unplaced = 0;
+    let read = (column, row) => readAs(2, column.storage, column.values[row]), write = (column, kind, row, value) => {
+      column.values[row] = writeAs(kind, column.storage, value);
+    }, open = false;
+    for (let row = 0; row < count; row++) {
+      let a = read(at, row);
+      if (a === 0) {
+        open = true;
+        continue;
+      }
+      let offset = a - 1, block = Math.floor(offset / this.k);
+      if (offset % this.k === 0 && block < this.blocks && this.used[block] === 0) {
+        this.used[block] = 1, read(len, row) > this.k && write(len, lenKind, row, this.k);
+        continue;
+      }
+      write(at, 2, row, 0), write(len, lenKind, row, 0), open = true;
+    }
+    if (!open) return;
+    let cursor = 0;
+    for (let row = 0; row < count; row++)
+      if (read(at, row) === 0) {
+        for (; cursor < this.blocks && this.used[cursor] !== 0; ) cursor++;
+        if (write(len, lenKind, row, 0), cursor === this.blocks) {
+          this.unplaced++;
+          continue;
+        }
+        this.used[cursor] = 1, write(at, 2, row, cursor * this.k + 1), cursor++;
+      }
+  }
+};
+function dataOps(code) {
+  let out = [], pc = 0;
+  for (; pc + 1 < code.length; ) {
+    let i = code[pc];
+    if (i.op === (175)) {
+      xopRange(i.dst) === XOP_RANGE.DATA && out.push({ pc, i, ext: code[pc + 1] }), pc += 2;
+      continue;
+    }
+    pc++;
+  }
+  return out;
+}
+function listDecls(code) {
+  return dataOps(code).filter((o) => o.i.dst === (12304)).map((o) => ({ at: o.i.a, len: o.i.b, pool: o.i.c, k: o.ext.a }));
+}
+var DataMachine = class {
+  constructor(slots, code, capacity) {
+    this.slots = slots;
+    this.code = code;
+    this.tableCapacity = new Array((16)).fill(0);
+    this.tableCount = new Array((16)).fill(0);
+    this.bound = new Array((16)).fill(false);
+    this.used = 1;
+    this.snaps = /* @__PURE__ */ new Map();
+    this.indexes = /* @__PURE__ */ new Map();
+    this.pools = /* @__PURE__ */ new Map();
+    this.sweeps = [];
+    this.sites = [];
+    this.commandCapacity = (8192);
+    this.pickCapacity = (256);
+    this.counter = 0;
+    this.tallies = new Uint32Array((64));
+    this.stats = { sent: 0, applied: 0, dropped: 0, overflow: 0 };
+    this.payload = new Uint32Array((4));
+    let ops = dataOps(code);
+    this.active = ops.length > 0, slots.forEach((slot, k) => {
+      let word = slot.word ?? 0, table = tableOf(word);
+      this.used |= 1 << table, table !== 0 && !isPool(word) && (word & 256) !== 0 && this.snaps.set(k, { table, values: new Float64Array(0), active: false });
+    });
+    for (let decl of listDecls(code)) {
+      if (this.pools.has(decl.pool)) continue;
+      let table = tableOf(slots[decl.pool].word ?? 0), sweep = this.sweeps.findIndex((s) => s.at === decl.at && s.len === decl.len);
+      sweep < 0 && (this.sweeps.push(new ListSweep(decl.at, decl.len, table, decl.k)), sweep = this.sweeps.length - 1), this.pools.set(decl.pool, { decl, words: 0, bound: false, sweep });
+    }
+    for (let { pc, i } of ops)
+      i.dst === (12288) ? (this.used |= 1 << i.b, this.indexes.has(i.c) || this.indexes.set(i.c, { table: i.b, index: new KeyIndex(0) })) : i.dst === (12289) ? this.used |= 1 << i.b : i.dst === (12291) ? this.used |= 1 << i.a : i.dst === (12336) && this.sites.push({ pc, n: i.a, rows: new Uint32Array(0), len: 0 });
+    this.commands = new Keep(this.commandCapacity, (4)), this.picks = [], this.bindPicks(this.pickCapacity), this.bindStorage(0, capacity), this.tableCapacity[0] = capacity, this.bound[0] = true;
+  }
+  bindStorage(table, capacity) {
+    for (let snap of this.snaps.values()) snap.table === table && (snap.values = new Float64Array(capacity));
+    for (let entry of this.indexes.values()) entry.table === table && (entry.index = new KeyIndex(capacity));
+  }
+  get tablesUsed() {
+    return this.used;
+  }
+  get poolDecls() {
+    return [...this.pools.values()].map((p) => p.decl);
+  }
+  get unplaced() {
+    return this.sweeps.reduce((sum, s) => sum + s.unplaced, 0);
+  }
+  bindTable(table, capacity) {
+    if (table < 1 || table >= (16)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `kernel tables are numbered 1..${(16) - 1}`);
+    this.tableCapacity[table] = capacity, this.bound[table] = true, this.bindStorage(table, capacity);
+  }
+  bindPool(slot, words2) {
+    let pool = this.pools.get(slot);
+    if (pool === void 0) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `slot ${slot} is not a list pool`);
+    pool.words = words2, pool.bound = true;
+    let sweep = this.sweeps[pool.sweep], blocks = 1 / 0;
+    for (let p of this.pools.values()) p.sweep === pool.sweep && (blocks = Math.min(blocks, p.bound ? Math.floor(p.words / sweep.k) : 1 / 0));
+    blocks !== 1 / 0 && sweep.bind(blocks);
+  }
+  bindCommands(capacity) {
+    this.commandCapacity = capacity, this.commands = new Keep(capacity, (4));
+  }
+  bindPicks(capacity) {
+    this.pickCapacity = capacity, this.picks = this.sites.map(() => new Keep(capacity, 0));
+    for (let site of this.sites) site.rows = new Uint32Array(capacity);
+  }
+  setCount(table, count) {
+    if (count > this.tableCapacity[table]) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", `table ${table} holds ${count} rows but was bound with capacity ${this.tableCapacity[table]}`);
+    this.tableCount[table] = count;
+  }
+  count(table) {
+    return this.tableCount[table];
+  }
+  pickRows(site) {
+    let s = this.sites[site];
+    return s === void 0 ? new Uint32Array(0) : s.rows.subarray(0, s.len);
+  }
+  prepare(columns, count) {
+    if (this.active) {
+      this.tableCount[0] = count;
+      for (let t = 1; t < (16); t++)
+        if ((this.used & 1 << t) !== 0 && !this.bound[t]) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `this kernel reads table ${t}, which is not bound; pass the table as its Rows argument`);
+      for (let [slot, pool] of this.pools) if (!pool.bound) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `list pool slot ${slot} is not bound`);
+      for (let [slot, snap] of this.snaps) {
+        let column = columns[slot];
+        if (snap.active = this.slots.some((s, k) => tableOf(s.word ?? 0) === 0 && !isPool(s.word ?? 0) && ((s.word ?? 0) & 512) !== 0 && sameColumn(columns[k], column)), snap.active) {
+          let n = this.tableCount[snap.table];
+          for (let row = 0; row < n; row++) snap.values[row] = column.values[row];
+        }
+      }
+      for (let sweep of this.sweeps) sweep.run(columns[sweep.at], columns[sweep.len], this.slots[sweep.len].kind, this.tableCount[sweep.table]);
+      for (let [slot, entry] of this.indexes) {
+        let column = columns[slot], kind = this.slots[slot].kind;
+        entry.index.build(this.tableCount[entry.table], (row) => readAs(kind, column.storage, column.values[row]));
+      }
+      this.commands.clear();
+      for (let p of this.picks) p.clear();
+      this.tallies.fill(0), this.counter = 0, this.stats = { sent: 0, applied: 0, dropped: 0, overflow: 0 };
+    }
+  }
+  exec(pc, i, ext, n, columns, host) {
+    let on = (mask, k) => mask === 4294967295 || host.lane(mask, k) !== 0;
+    switch (i.dst) {
+      case (12288): {
+        let index = this.indexes.get(i.c).index;
+        for (let k = 0; k < n; k++) host.set(ext.dst, k, index.find(host.lane(i.a, k)));
+        return;
+      }
+      case (12289): {
+        let count = this.tableCount[i.b];
+        for (let k = 0; k < n; k++) {
+          let v = host.lane(i.a, k) >>> 0;
+          host.set(ext.dst, k, v < count ? v : 4294967295);
+        }
+        return;
+      }
+      case (12290): {
+        let slot = this.slots[i.a], column = columns[i.a], count = this.tableCount[tableOf(slot.word ?? 0)], snap = this.snaps.get(i.a), values = snap !== void 0 && snap.active ? snap.values : column.values;
+        for (let k = 0; k < n; k++) {
+          let r = host.lane(i.b, k) >>> 0;
+          host.set(ext.dst, k, r < count ? readAs(slot.kind, column.storage, values[r]) : 0);
+        }
+        return;
+      }
+      case (12291): {
+        let count = this.tableCount[i.a];
+        for (let k = 0; k < n; k++) host.set(ext.dst, k, count);
+        return;
+      }
+      case (12305):
+      case (12306): {
+        let pool = this.pools.get(i.a), at = columns[pool.decl.at], column = columns[i.a], kind = this.slots[i.a].kind, setting = i.dst === (12306), mask = setting ? ext.a : i.c;
+        for (let k = 0; k < n; k++) {
+          let value = 0;
+          if (on(mask, k)) {
+            let base = readAs(2, at.storage, at.values[host.row(k)]), e = host.lane(i.b, k) >>> 0, cell = base - 1 + e;
+            base !== 0 && e < pool.decl.k && cell < pool.words && (setting ? column.values[cell] = writeAs(kind, column.storage, host.lane(i.c, k)) : value = readAs(kind, column.storage, column.values[cell]));
+          }
+          setting || host.set(ext.dst, k, value);
+        }
+        return;
+      }
+      case (12307): {
+        let active = 0;
+        for (let k = 0; k < n; k++) on(i.b, k) && active++;
+        this.tallies[i.a] = this.tallies[i.a] + active >>> 0;
+        return;
+      }
+      case (12320): {
+        let count = this.tableCount[tableOf(this.slots[i.a].word ?? 0)];
+        for (let k = 0; k < n; k++) {
+          let target = host.lane(i.b, k) >>> 0;
+          !on(ext.a, k) || target >= count || (this.payload[0] = i.a, this.payload[1] = ext.b, this.payload[2] = target, this.payload[3] = host.lane(i.c, k), this.commands.insert(host.row(k), this.counter++, 0, this.payload));
+        }
+        return;
+      }
+      case (12336): {
+        let site = this.sites.findIndex((s) => s.pc === pc), keep = this.picks[site];
+        for (let k = 0; k < n; k++)
+          on(i.c, k) && keep.insert(pickOrder(ext.a, host.lane(i.b, k)), host.row(k), 0, null);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  finish(columns, uniforms) {
+    this.active && (this.finishCommands(columns), this.sites.forEach((site, s) => {
+      let keep = this.picks[s], order = Array.from({ length: keep.len }, (_, k) => k).sort((p, q) => keep.compare(p, q)), want = Math.max(uniforms[site.n & 2147483647] | 0, 0), n = Math.min(want, order.length, site.rows.length);
+      for (let k = 0; k < n; k++) site.rows[k] = keep.b[order[k]];
+      site.len = n;
+    }));
+  }
+  finishCommands(columns) {
+    let keep = this.commands, offered = keep.len + keep.dropped;
+    if (keep.len === 0) return;
+    let table = (k) => tableOf(this.slots[keep.data[k * (4)]].word ?? 0), order = Array.from({ length: keep.len }, (_, k) => k);
+    order.sort((p, q) => table(p) - table(q) || keep.data[p * (4) + 2] - keep.data[q * (4) + 2] || keep.compare(p, q));
+    let overflow = 0;
+    for (let k of order) {
+      let at = k * (4), slot = keep.data[at], mode = keep.data[at + 1], row = keep.data[at + 2], value = keep.data[at + 3], kind = this.slots[slot].kind, column = columns[slot];
+      if (mode === SEND.PUSH) {
+        let pool = this.pools.get(slot), base = columns[pool.decl.at], length = columns[pool.decl.len], start = readAs(2, base.storage, base.values[row]), used = readAs(2, length.storage, length.values[row]), cell = start - 1 + used;
+        if (start === 0 || used >= pool.decl.k || cell >= pool.words) {
+          overflow++;
+          continue;
+        }
+        column.values[cell] = writeAs(kind, column.storage, value), length.values[row] = writeAs(this.slots[pool.decl.len].kind, length.storage, used + 1);
+        continue;
+      }
+      let current = readAs(kind, column.storage, column.values[row]), next = command(mode, current, value);
+      (exact(kind, column.storage) || current !== next) && (column.values[row] = writeAs(kind, column.storage, next));
+    }
+    this.stats = { sent: offered, applied: keep.len - overflow, dropped: offered - keep.len, overflow };
+  }
+};
+
+exports.ACCESS_ARRAY = (65536);
+exports.ACCESS_INDEXED = ACCESS_INDEXED;
+exports.ACCESS_NEIGHBOUR = (1024);
+exports.ACCESS_READ = (256);
+exports.ACCESS_SCRATCH = (2048);
+exports.ACCESS_SPAWN = (8192);
+exports.ACCESS_WRITE = (512);
+exports.ARG_FMAX = (1);
+exports.ARG_FMIN = (0);
+exports.ARG_IMAX = (3);
+exports.ARG_IMIN = (2);
+exports.ARG_UMIN = (4);
+exports.ATTACH_AUDIO = (5);
+exports.ATTACH_CHEMISTRY_GRID = (7);
+exports.ATTACH_SPAWN_TABLE = (9);
+exports.ATTACH_UI = (4);
+exports.ATTACH_VOXELS = (6);
+exports.CANONICAL_NAN32 = (2143289344);
+exports.CELL_WRAP = CELL_WRAP;
+exports.CHANNEL_WORDS = (4);
+exports.CROSS_BLOCK = (256);
+exports.CROSS_OP = CROSS_OP;
+exports.CURVE_HEADER = (4);
+exports.CURVE_HERMITE = (2);
+exports.CURVE_LINEAR = (1);
+exports.CURVE_STEP = (0);
+exports.DATA_FLOAD = (12290);
+exports.DATA_KEYOF = (12288);
+exports.DATA_LIST = (12304);
+exports.DATA_LIST_MAX = (4096);
+exports.DATA_PGET = (12305);
+exports.DATA_PICK = (12336);
+exports.DATA_PSET = (12306);
+exports.DATA_REPORT_HEADER = (70);
+exports.DATA_ROWOF = (12289);
+exports.DATA_ROWS = (12291);
+exports.DATA_SEND = (12320);
+exports.DATA_TABLES = (16);
+exports.DATA_TALLIES = (64);
+exports.DATA_TALLY = (12307);
+exports.DEFAULT_EVENT_CAPACITY = (4096);
+exports.DST_BITS = (8);
+exports.DataMachine = DataMachine;
+exports.EVENT_HEADER_WORDS = (2);
+exports.EVENT_STRIDE = (10);
+exports.FLAG_GROUPS = (2);
+exports.FLAG_NEIGHBOURS = (1);
+exports.FMATH_CONSTANTS = FMATH_CONSTANTS;
+exports.GRAPH_EMPTY = (4294967295);
+exports.GROUP_DEFAULT = (1);
+exports.GROUP_WORDS = (4);
+exports.H_ARGS = (5);
+exports.H_CONSTANTS = (6);
+exports.H_EVENTS = (14);
+exports.H_FLAGS = (2);
+exports.H_GROUPS = (9);
+exports.H_INSTRUCTIONS = (8);
+exports.H_LOOPS = (7);
+exports.H_MAGIC = (0);
+exports.H_POSITION_X = (11);
+exports.H_POSITION_Y = (12);
+exports.H_POSITION_Z = (13);
+exports.H_REGISTERS = (3);
+exports.H_SLOTS = (4);
+exports.H_STATE = (10);
+exports.H_VERSION = (1);
+exports.INSTRUCTION_WORDS = (4);
+exports.KERNEL_CALL_EXPORT_NAMES = KERNEL_CALL_EXPORT_NAMES;
+exports.KERNEL_DATA_EXPORT_NAMES = KERNEL_DATA_EXPORT_NAMES;
+exports.KERNEL_EXPORT_NAMES = KERNEL_EXPORT_NAMES;
+exports.KERNEL_ISA_BASE = (1);
+exports.KERNEL_ISA_CALLS = (2);
+exports.KERNEL_ISA_EXTENDED = (4);
+exports.KERNEL_ISA_VERSION = (4);
+exports.KERNEL_ISA_WRITES = (3);
+exports.KERNEL_SCAN_FEATURE = KERNEL_SCAN_FEATURE;
+exports.KERNEL_STAGE_EXPORT_NAMES = KERNEL_STAGE_EXPORT_NAMES;
+exports.KERNEL_WRITE_EXPORT_NAMES = KERNEL_WRITE_EXPORT_NAMES;
+exports.KIND_BOOL = (3);
+exports.KIND_F32 = (0);
+exports.KIND_I32 = (1);
+exports.KIND_U32 = (2);
+exports.LIBRARY_HEADER_WORDS = (4);
+exports.LIBRARY_MAGIC = (827083587);
+exports.LOOKUP_OP = LOOKUP_OP;
+exports.LOOP_COUNT_F32 = (1);
+exports.LUT1_HEADER = (4);
+exports.LUT2_HEADER = (8);
+exports.LUT_LINEAR = (1);
+exports.LUT_WRAP = (2);
+exports.ListSweep = ListSweep;
+exports.MAX_CHANNELS = (64);
+exports.MAX_EVENT_WORDS = (8);
+exports.MAX_TRIPS = (65536);
+exports.MLP_MAX_OUTPUTS = (32);
+exports.MLP_MAX_WIDTH = (128);
+exports.NONE = (4294967295);
+exports.Op = Op;
+exports.PROGRAM_HEADER_WORDS = (16);
+exports.PROGRAM_MAGIC = (827345731);
+exports.QFILTER_ANY = (2);
+exports.QFILTER_EQUAL = (1);
+exports.QFILTER_NONE = (3);
+exports.QUERY_BOX = (2);
+exports.QUERY_CONE = (1);
+exports.QUERY_FILTERED = (4);
+exports.QUERY_SEGMENT = (3);
+exports.QUERY_SHAPE = (3);
+exports.QUERY_SPHERE = (0);
+exports.RECUR = RECUR;
+exports.RECUR_EXCLUSIVE = (32);
+exports.RECUR_KIND_MASK = (31);
+exports.RECUR_WIDE = (64);
+exports.REDUCE_FMAX = (3);
+exports.REDUCE_FMIN = (2);
+exports.REDUCE_FSUM = (0);
+exports.REDUCE_IMAX = (5);
+exports.REDUCE_IMIN = (4);
+exports.REDUCE_ISUM = (1);
+exports.REDUCE_UMIN = (6);
+exports.RING_COUNT = (0);
+exports.RING_DROPPED = (1);
+exports.RING_HEADER_WORDS = (2);
+exports.SAMPLER_WORDS = (8);
+exports.SAMPLE_BILINEAR = (1);
+exports.SAMPLE_NEAREST = (0);
+exports.SAMPLE_NORMAL_X = (2);
+exports.SAMPLE_NORMAL_Y = (3);
+exports.SAMPLE_NORMAL_Z = (4);
+exports.SCAN_F_EXCLUSIVE = (1);
+exports.SCAN_F_INCLUSIVE = (0);
+exports.SCAN_I_INCLUSIVE = (2);
+exports.SCATTER_FADD = (0);
+exports.SERVICE_ANCHOR = (16);
+exports.SERVICE_CHEMISTRY = (21);
+exports.SERVICE_CLIP_WEIGHT = (11);
+exports.SERVICE_FLOW = (5);
+exports.SERVICE_FORCE = (6);
+exports.SERVICE_GROUND_HEIGHT = (3);
+exports.SERVICE_IK_TARGET = (13);
+exports.SERVICE_IMPULSE = (7);
+exports.SERVICE_INSTANCE = (14);
+exports.SERVICE_INSTANCE_COLOUR = (15);
+exports.SERVICE_KILL = (23);
+exports.SERVICE_LINE_OF_SIGHT = (2);
+exports.SERVICE_OVERLAP = (9);
+exports.SERVICE_PATH = (4);
+exports.SERVICE_PICK = (18);
+exports.SERVICE_PLAY_CLIP = (12);
+exports.SERVICE_RAYCAST = (1);
+exports.SERVICE_SIGNATURES = SERVICE_SIGNATURES;
+exports.SERVICE_SOUND = (17);
+exports.SERVICE_SWEEP = (10);
+exports.SERVICE_VELOCITY = (8);
+exports.SERVICE_VOXEL_GET = (19);
+exports.SERVICE_VOXEL_SET = (20);
+exports.SIMD_CROSS = (28948);
+exports.SIMD_DOT = (28944);
+exports.SIMD_DOT_F32 = (0);
+exports.SIMD_EXTRACT = (28929);
+exports.SIMD_LANE_BITS = (3);
+exports.SIMD_LANE_MASK = SIMD_LANE_MASK;
+exports.SIMD_LENGTH = (28946);
+exports.SIMD_MAP = (28672);
+exports.SIMD_MAP_OPS = (256);
+exports.SIMD_NORMALIZE = (28947);
+exports.SIMD_PACK = (28931);
+exports.SIMD_REDUCE = (28945);
+exports.SIMD_REPLACE = (28930);
+exports.SIMD_SCALAR_A = (8);
+exports.SIMD_SCALAR_B = (16);
+exports.SIMD_SCALAR_C = (32);
+exports.SIMD_SHUFFLE = (28928);
+exports.SIMD_WIDTH_MASK = (7);
+exports.SORT_DESCENDING = (4);
+exports.SORT_KEY_MASK = (3);
+exports.SORT_RADIX_BITS = (8);
+exports.SPAWN_STATS_WORDS = (3);
+exports.STATUS_FAILURE = (0);
+exports.STATUS_RUNNING = (2);
+exports.STATUS_SUCCESS = (1);
+exports.UNIFORM = (2147483648);
+exports.XOP = (175);
+exports.XOP_COMPONENTS_EDGES = (20483);
+exports.XOP_COMPONENTS_GRID = (20480);
+exports.XOP_FIELD = (17);
+exports.XOP_GATHER = (16);
+exports.XOP_GROUP = (3);
+exports.XOP_MLP_IN = (24576);
+exports.XOP_MLP_MOE = (24579);
+exports.XOP_MLP_OUT = (24578);
+exports.XOP_QFILTER = (4098);
+exports.XOP_QRANK = (4100);
+exports.XOP_QSHAPE = (4097);
+exports.XOP_QSTOP = (4099);
+exports.XOP_QUERY = (4096);
+exports.XOP_RANGE = XOP_RANGE;
+exports.XOP_REACH_GRID = (20481);
+exports.XOP_RECUR_IN = (33);
+exports.XOP_SORT = (1);
+exports.XOP_TOPK = (2);
+exports.acos = acos;
+exports.asin = asin;
+exports.atan = atan;
+exports.atan2 = atan2;
+exports.cos = cos;
+exports.crossRow = crossRow;
+exports.curveWords = curveWords;
+exports.deferredService = deferredService;
+exports.evalLane = evalLane;
+exports.exp = exp;
+exports.f32Bits = f32Bits;
+exports.f32From = f32From;
+exports.fmath64_exports = fmath64_exports;
+exports.fmath_exports = fmath_exports;
+exports.isa_exports = isa_exports;
+exports.joinF64 = joinF64;
+exports.joinU64 = joinU64;
+exports.laneSignature = laneSignature;
+exports.lanes_exports = lanes_exports;
+exports.log = log;
+exports.log2 = log2;
+exports.lookupOp = lookupOp;
+exports.operandCount = operandCount;
+exports.pow = pow;
+exports.readAs = readAs;
+exports.recurStateWords = recurStateWords;
+exports.recurSub = recurSub;
+exports.runLanes = runLanes;
+exports.serviceOf = serviceOf;
+exports.sin = sin;
+exports.sortKey = sortKey;
+exports.stageEndingOp = stageEndingOp;
+exports.stageEnds = stageEnds;
+exports.symbol = symbol;
+exports.tan = tan;
+exports.toUint32 = toUint32;
+exports.toUint64 = toUint64;
+exports.xopRange = xopRange;