@loro-dev/flock-sqlite 0.1.0

package/src/memcomparable.ts

@@ -0,0 +1,1852 @@
+// @ts-nocheck
+// NOTE: generated from moon/memcomparable; intentionally skips type checking.
+const $9221120237041090561L = { hi: 2146959360, lo: 1 };
+class $PanicError extends Error {}
+function $panic() {
+  throw new $PanicError();
+}
+const moonbitlang$core$bigint$$BigInt$compare = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+const moonbitlang$core$bigint$$BigInt$equal = (x, y) => x === y;
+const moonbitlang$core$bigint$$BigInt$from_int64 = (x) => BigInt(x.hi) * 0x100000000n + BigInt(x.lo >>> 0);
+const moonbitlang$core$bigint$$BigInt$op_neg_ffi = (x) => -x;
+const moonbitlang$core$bigint$$BigInt$op_add_ffi = (x, y) => x + y;
+const moonbitlang$core$bigint$$BigInt$op_mul_ffi = (x, y) => x * y;
+const moonbitlang$core$bigint$$BigInt$op_div_ffi = (x, y) => x / y;
+const moonbitlang$core$bigint$$BigInt$op_mod_ffi = (x, y) => x % y;
+const moonbitlang$core$bigint$$BigInt$js_shr = (x, y) => x >> BigInt(y);
+const moonbitlang$core$bigint$$BigInt$to_uint = (x) => Number(BigInt.asUintN(32, x)) | 0;
+const moonbitlang$core$bigint$$BigInt$to_int = (x) => Number(BigInt.asIntN(32, x));
+function $bound_check(arr, index) {
+  if (index < 0 || index >= arr.length) throw new Error("Index out of bounds");
+}
+const moonbitlang$core$builtin$$int_to_string_js = (x, radix) => {
+  return x.toString(radix);
+};
+function $makebytes(a, b) {
+  const arr = new Uint8Array(a);
+  if (b !== 0) {
+    arr.fill(b);
+  }
+  return arr;
+}
+const moonbitlang$core$builtin$$JSArray$push = (arr, val) => { arr.push(val); };
+const $64$moonbitlang$47$core$47$builtin$46$ForeachResult$Continue$0$ = { $tag: 0 };
+function $64$moonbitlang$47$core$47$builtin$46$ForeachResult$Break$0$(param0) {
+  this._0 = param0;
+}
+$64$moonbitlang$47$core$47$builtin$46$ForeachResult$Break$0$.prototype.$tag = 1;
+function $64$moonbitlang$47$core$47$builtin$46$ForeachResult$Return$0$(param0) {
+  this._0 = param0;
+}
+$64$moonbitlang$47$core$47$builtin$46$ForeachResult$Return$0$.prototype.$tag = 2;
+function $64$moonbitlang$47$core$47$builtin$46$ForeachResult$Error$0$(param0) {
+  this._0 = param0;
+}
+$64$moonbitlang$47$core$47$builtin$46$ForeachResult$Error$0$.prototype.$tag = 3;
+function $64$moonbitlang$47$core$47$builtin$46$ForeachResult$JumpOuter$0$(param0) {
+  this._0 = param0;
+}
+$64$moonbitlang$47$core$47$builtin$46$ForeachResult$JumpOuter$0$.prototype.$tag = 4;
+const moonbitlang$core$builtin$$MyInt64$reinterpret_as_double = function f(a) {
+  let view = f._view;
+  if (view === undefined) {
+    view = f._view = new DataView(new ArrayBuffer(8));
+  }
+  view.setUint32(0, a.hi);
+  view.setUint32(4, a.lo);
+  return view.getFloat64(0);
+};
+const moonbitlang$core$builtin$$MyInt64$reinterpret_double = function f(a) {
+  let view = f._view;
+  if (view === undefined) {
+    view = f._view = new DataView(new ArrayBuffer(8));
+  }
+  view.setFloat64(0, a);
+  const hi = view.getInt32(0);
+  const lo = view.getInt32(4);
+  return { hi, lo };
+};
+const moonbitlang$core$builtin$$MyInt64$convert_to_double = (a) => a.hi * 4294967296.0 + (a.lo >>> 0);
+const moonbitlang$core$builtin$$MyInt64$from_double = (a) => {
+  if (isNaN(a)) {
+    return { hi: 0, lo: 0 };
+  }
+  if (a >= 9223372036854775807) {
+    return { hi: 0x7fffffff, lo: 0xffffffff };
+  }
+  if (a <= -9223372036854775808) {
+    return { hi: -2147483648, lo: 0 };
+  }
+  let neg = false;
+  if (a < 0) {
+    neg = true;
+    a = -a;
+  }
+  let hi = (a * (1 / 0x100000000)) | 0;
+  let lo = a >>> 0;
+  if (neg) {
+    if (lo === 0) {
+      hi = ~hi + 1;
+    } else {
+      hi = ~hi;
+      lo = ~lo + 1;
+    }
+  }
+  return { hi, lo };
+};
+const $bytes_literal$0 = new Uint8Array();
+const $255L = { hi: 0, lo: 255 };
+const $0L = { hi: 0, lo: 0 };
+const $_1L = { hi: -1, lo: -1 };
+const $_9223372036854775808L = { hi: -2147483648, lo: 0 };
+function Result$Err$1$(param0) {
+  this._0 = param0;
+}
+Result$Err$1$.prototype.$tag = 0;
+function Result$Ok$1$(param0) {
+  this._0 = param0;
+}
+Result$Ok$1$.prototype.$tag = 1;
+function Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$InvalidTag(param0) {
+  this._0 = param0;
+}
+Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$InvalidTag.prototype.$tag = 2;
+const Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF = { $tag: 1 };
+const Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$InvalidUTF8 = { $tag: 0 };
+const $1L = { hi: 0, lo: 1 };
+const $256L = { hi: 0, lo: 256 };
+function Result$Err$2$(param0) {
+  this._0 = param0;
+}
+Result$Err$2$.prototype.$tag = 0;
+function Result$Ok$2$(param0) {
+  this._0 = param0;
+}
+Result$Ok$2$.prototype.$tag = 1;
+function Result$Err$3$(param0) {
+  this._0 = param0;
+}
+Result$Err$3$.prototype.$tag = 0;
+function Result$Ok$3$(param0) {
+  this._0 = param0;
+}
+Result$Ok$3$.prototype.$tag = 1;
+function KeyPart$Bytes(param0) {
+  this._0 = param0;
+}
+KeyPart$Bytes.prototype.$tag = 0;
+function KeyPart$String(param0) {
+  this._0 = param0;
+}
+KeyPart$String.prototype.$tag = 1;
+function KeyPart$Int(param0) {
+  this._0 = param0;
+}
+KeyPart$Int.prototype.$tag = 2;
+function KeyPart$Float(param0) {
+  this._0 = param0;
+}
+KeyPart$Float.prototype.$tag = 3;
+const KeyPart$False = { $tag: 4 };
+const KeyPart$True = { $tag: 5 };
+function Result$Err$4$(param0) {
+  this._0 = param0;
+}
+Result$Err$4$.prototype.$tag = 0;
+function Result$Ok$4$(param0) {
+  this._0 = param0;
+}
+Result$Ok$4$.prototype.$tag = 1;
+function KeyJsPart$Number(param0) {
+  this._0 = param0;
+}
+KeyJsPart$Number.prototype.$tag = 0;
+function KeyJsPart$String(param0) {
+  this._0 = param0;
+}
+KeyJsPart$String.prototype.$tag = 1;
+function KeyJsPart$Bytes(param0) {
+  this._0 = param0;
+}
+KeyJsPart$Bytes.prototype.$tag = 2;
+const KeyJsPart$True = { $tag: 3 };
+const KeyJsPart$False = { $tag: 4 };
+const zxch3n$expect$$to_string$46$42$bind$124$178 = ";";
+const zxch3n$expect$$red$46$constr$47$350 = 1;
+const zxch3n$expect$$yellow$46$constr$47$352 = 3;
+const zxch3n$expect$$blue$46$constr$47$354 = 4;
+const moonbitlang$core$double$$not_a_number = moonbitlang$core$int64$$Int64$reinterpret_as_double($9221120237041090561L);
+function moonbitlang$core$abort$$abort$0$(msg) {
+  return $panic();
+}
+function moonbitlang$core$abort$$abort$1$(msg) {
+  return $panic();
+}
+function moonbitlang$core$abort$$abort$2$(msg) {
+  return $panic();
+}
+function moonbitlang$core$abort$$abort$3$(msg) {
+  $panic();
+}
+function moonbitlang$core$abort$$abort$4$(msg) {
+  return $panic();
+}
+function moonbitlang$core$uint$$UInt$to_int64(self) {
+  return moonbitlang$core$uint$$UInt$to_uint64(self);
+}
+function moonbitlang$core$array$$ArrayView$join$5$(self, separator) {
+  if ((self.end - self.start | 0) === 0) {
+    return "";
+  } else {
+    const _hd = self.buf[self.start];
+    const _bind = self.buf;
+    const _bind$2 = 1 + self.start | 0;
+    const _bind$3 = self.end;
+    const _x = { buf: _bind, start: _bind$2, end: _bind$3 };
+    const hd = moonbitlang$core$string$$ToStringView$to_string_view$5$(_hd);
+    let size_hint = hd.end - hd.start | 0;
+    const _len = _x.end - _x.start | 0;
+    let _tmp = 0;
+    while (true) {
+      const _i = _tmp;
+      if (_i < _len) {
+        const s = _bind[_bind$2 + _i | 0];
+        const _tmp$2 = size_hint;
+        const _p = moonbitlang$core$string$$ToStringView$to_string_view$5$(s);
+        size_hint = _tmp$2 + ((_p.end - _p.start | 0) + (separator.end - separator.start | 0) | 0) | 0;
+        _tmp = _i + 1 | 0;
+        continue;
+      } else {
+        break;
+      }
+    }
+    size_hint = size_hint << 1;
+    const buf = moonbitlang$core$builtin$$StringBuilder$new$46$inner(size_hint);
+    moonbitlang$core$builtin$$Logger$write_substring$6$(buf, hd.str, hd.start, hd.end - hd.start | 0);
+    if (moonbitlang$core$string$$String$char_length_eq$46$inner(separator.str, 0, separator.start, separator.end)) {
+      const _len$2 = _x.end - _x.start | 0;
+      let _tmp$2 = 0;
+      while (true) {
+        const _i = _tmp$2;
+        if (_i < _len$2) {
+          const s = _bind[_bind$2 + _i | 0];
+          const s$2 = moonbitlang$core$string$$ToStringView$to_string_view$5$(s);
+          moonbitlang$core$builtin$$Logger$write_substring$6$(buf, s$2.str, s$2.start, s$2.end - s$2.start | 0);
+          _tmp$2 = _i + 1 | 0;
+          continue;
+        } else {
+          break;
+        }
+      }
+    } else {
+      const _len$2 = _x.end - _x.start | 0;
+      let _tmp$2 = 0;
+      while (true) {
+        const _i = _tmp$2;
+        if (_i < _len$2) {
+          const s = _bind[_bind$2 + _i | 0];
+          const s$2 = moonbitlang$core$string$$ToStringView$to_string_view$5$(s);
+          moonbitlang$core$builtin$$Logger$write_substring$6$(buf, separator.str, separator.start, separator.end - separator.start | 0);
+          moonbitlang$core$builtin$$Logger$write_substring$6$(buf, s$2.str, s$2.start, s$2.end - s$2.start | 0);
+          _tmp$2 = _i + 1 | 0;
+          continue;
+        } else {
+          break;
+        }
+      }
+    }
+    return buf.val;
+  }
+}
+function moonbitlang$core$array$$Array$push_iter$7$(self, iter) {
+  iter((x) => {
+    moonbitlang$core$array$$Array$push$7$(self, x);
+    return 1;
+  });
+}
+function moonbitlang$core$array$$Array$join$5$(self, separator) {
+  return moonbitlang$core$array$$ArrayView$join$5$({ buf: self, start: 0, end: self.length }, separator);
+}
+function moonbitlang$core$builtin$$Compare$compare$8$(self, other) {
+  return moonbitlang$core$bigint$$BigInt$compare(self, other);
+}
+function moonbitlang$core$builtin$$Eq$equal$8$(self, other) {
+  return moonbitlang$core$bigint$$BigInt$equal(self, other);
+}
+function moonbitlang$core$builtin$$Neg$neg$8$(self) {
+  return moonbitlang$core$bigint$$BigInt$op_neg_ffi(self);
+}
+function moonbitlang$core$builtin$$Add$add$8$(self, other) {
+  return moonbitlang$core$bigint$$BigInt$op_add_ffi(self, other);
+}
+function moonbitlang$core$builtin$$Mul$mul$8$(self, other) {
+  return moonbitlang$core$bigint$$BigInt$op_mul_ffi(self, other);
+}
+function moonbitlang$core$builtin$$Div$div$8$(self, other) {
+  return moonbitlang$core$bigint$$BigInt$op_div_ffi(self, other);
+}
+function moonbitlang$core$builtin$$Mod$mod$8$(self, other) {
+  return moonbitlang$core$bigint$$BigInt$op_mod_ffi(self, other);
+}
+function moonbitlang$core$builtin$$Shr$shr$8$(self, n) {
+  if (n < 0) {
+    moonbitlang$core$abort$$abort$3$("negative shift count");
+  }
+  return moonbitlang$core$bigint$$BigInt$js_shr(self, n);
+}
+function moonbitlang$core$bigint$$BigInt$to_int64(self) {
+  const hi = moonbitlang$core$bigint$$BigInt$to_uint(moonbitlang$core$builtin$$Shr$shr$8$(self, 32));
+  const lo = moonbitlang$core$bigint$$BigInt$to_uint(self);
+  return moonbitlang$core$builtin$$BitOr$lor$9$(moonbitlang$core$builtin$$Shl$shl$9$(moonbitlang$core$uint$$UInt$to_int64(hi), 32), moonbitlang$core$uint$$UInt$to_int64(lo));
+}
+function moonbitlang$core$bytes$$BytesView$at(self, index) {
+  if (index >= 0 && index < (self.end - self.start | 0)) {
+    const _tmp = self.bytes;
+    const _tmp$2 = self.start + index | 0;
+    $bound_check(_tmp, _tmp$2);
+    return _tmp[_tmp$2];
+  } else {
+    return moonbitlang$core$abort$$abort$2$(`index out of bounds: the len is from 0 to ${moonbitlang$core$builtin$$Show$to_string$10$(self.end - self.start | 0)} but the index is ${moonbitlang$core$builtin$$Show$to_string$10$(index)}`);
+  }
+}
+function moonbitlang$core$bytes$$Bytes$sub$46$inner(self, start, end) {
+  const len = self.length;
+  let end$2;
+  if (end === undefined) {
+    end$2 = len;
+  } else {
+    const _Some = end;
+    const _end = _Some;
+    end$2 = _end < 0 ? len + _end | 0 : _end;
+  }
+  const start$2 = start < 0 ? len + start | 0 : start;
+  return start$2 >= 0 && (start$2 <= end$2 && end$2 <= len) ? { bytes: self, start: start$2, end: end$2 } : moonbitlang$core$abort$$abort$1$("Invalid index for View");
+}
+function moonbitlang$core$bytes$$BytesView$sub$46$inner(self, start, end) {
+  const len = self.end - self.start | 0;
+  let end$2;
+  if (end === undefined) {
+    end$2 = len;
+  } else {
+    const _Some = end;
+    const _end = _Some;
+    end$2 = _end < 0 ? len + _end | 0 : _end;
+  }
+  const start$2 = start < 0 ? len + start | 0 : start;
+  return start$2 >= 0 && (start$2 <= end$2 && end$2 <= len) ? { bytes: self.bytes, start: self.start + start$2 | 0, end: (self.start + start$2 | 0) + (end$2 - start$2 | 0) | 0 } : moonbitlang$core$abort$$abort$1$("Invalid index for View");
+}
+function moonbitlang$core$bytes$$BytesView$iter(self) {
+  const _p = (yield_) => {
+    const _end383 = self.end - self.start | 0;
+    let _tmp = 0;
+    while (true) {
+      const i = _tmp;
+      if (i < _end383) {
+        const _bind = yield_(moonbitlang$core$bytes$$BytesView$at(self, i));
+        if (_bind === 1) {
+        } else {
+          return 0;
+        }
+        _tmp = i + 1 | 0;
+        continue;
+      } else {
+        return 1;
+      }
+    }
+  };
+  return _p;
+}
+function moonbitlang$core$bytes$$BytesView$iterator(self) {
+  const i = { val: 0 };
+  const len = self.end - self.start | 0;
+  const _p = () => {
+    if (i.val < len) {
+      const _p$2 = i.val;
+      const _tmp = self.bytes;
+      const _tmp$2 = self.start + _p$2 | 0;
+      $bound_check(_tmp, _tmp$2);
+      const result = _tmp[_tmp$2];
+      i.val = i.val + 1 | 0;
+      return result;
+    } else {
+      return -1;
+    }
+  };
+  return _p;
+}
+function moonbitlang$core$bytes$$Bytes$from_array(arr) {
+  return moonbitlang$core$bytes$$Bytes$makei$11$(arr.end - arr.start | 0, (i) => moonbitlang$core$array$$ArrayView$at$2$(arr, i));
+}
+function moonbitlang$core$bytes$$Bytes$from_iter(iter) {
+  const _bind = moonbitlang$core$builtin$$Iter$collect$2$(iter);
+  return moonbitlang$core$bytes$$Bytes$from_array({ buf: _bind, start: 0, end: _bind.length });
+}
+function moonbitlang$core$byte$$Byte$to_uint64(self) {
+  return moonbitlang$core$uint$$UInt$to_uint64(self);
+}
+function moonbitlang$core$string$$ToStringView$to_string_view$5$(self) {
+  return { str: self, start: 0, end: self.length };
+}
+function moonbitlang$core$array$$FixedArray$unsafe_blit$2$(dst, dst_offset, src, src_offset, len) {
+  if (dst === src && dst_offset < src_offset) {
+    let _tmp = 0;
+    while (true) {
+      const i = _tmp;
+      if (i < len) {
+        const _tmp$2 = dst_offset + i | 0;
+        const _tmp$3 = src_offset + i | 0;
+        $bound_check(src, _tmp$3);
+        $bound_check(dst, _tmp$2);
+        dst[_tmp$2] = src[_tmp$3];
+        _tmp = i + 1 | 0;
+        continue;
+      } else {
+        return;
+      }
+    }
+  } else {
+    let _tmp = len - 1 | 0;
+    while (true) {
+      const i = _tmp;
+      if (i >= 0) {
+        const _tmp$2 = dst_offset + i | 0;
+        const _tmp$3 = src_offset + i | 0;
+        $bound_check(src, _tmp$3);
+        $bound_check(dst, _tmp$2);
+        dst[_tmp$2] = src[_tmp$3];
+        _tmp = i - 1 | 0;
+        continue;
+      } else {
+        return;
+      }
+    }
+  }
+}
+function moonbitlang$core$builtin$$StringBuilder$new$46$inner(size_hint) {
+  return { val: "" };
+}
+function moonbitlang$core$builtin$$Logger$write_char$6$(self, ch) {
+  const _bind = self;
+  _bind.val = `${_bind.val}${String.fromCodePoint(ch)}`;
+}
+function moonbitlang$core$builtin$$Logger$write_string$6$(self, str) {
+  const _bind = self;
+  _bind.val = `${_bind.val}${str}`;
+}
+function moonbitlang$core$builtin$$Compare$op_gt$12$(x, y) {
+  return moonbitlang$core$builtin$$Compare$compare$8$(x, y) > 0;
+}
+function moonbitlang$core$builtin$$Show$to_string$10$(self) {
+  const logger = moonbitlang$core$builtin$$StringBuilder$new$46$inner(0);
+  moonbitlang$core$builtin$$Show$output$13$(self, { self: logger, method_0: moonbitlang$core$builtin$$Logger$write_string$6$, method_1: moonbitlang$core$builtin$$Logger$write_substring$6$, method_2: moonbitlang$core$builtin$$Logger$write_char$6$ });
+  return logger.val;
+}
+function moonbitlang$core$int$$Int$to_string$46$inner(self, radix) {
+  return moonbitlang$core$builtin$$int_to_string_js(self, radix);
+}
+function moonbitlang$core$string$$String$char_length_eq$46$inner(self, len, start_offset, end_offset) {
+  let end_offset$2;
+  if (end_offset === undefined) {
+    end_offset$2 = self.length;
+  } else {
+    const _Some = end_offset;
+    end_offset$2 = _Some;
+  }
+  let _tmp = start_offset;
+  let _tmp$2 = 0;
+  while (true) {
+    const index = _tmp;
+    const count = _tmp$2;
+    if (index < end_offset$2 && count < len) {
+      const c1 = self.charCodeAt(index);
+      if (55296 <= c1 && c1 <= 56319 && (index + 1 | 0) < end_offset$2) {
+        const _tmp$3 = index + 1 | 0;
+        const c2 = self.charCodeAt(_tmp$3);
+        if (56320 <= c2 && c2 <= 57343) {
+          _tmp = index + 2 | 0;
+          _tmp$2 = count + 1 | 0;
+          continue;
+        } else {
+          moonbitlang$core$abort$$abort$3$("invalid surrogate pair");
+        }
+      }
+      _tmp = index + 1 | 0;
+      _tmp$2 = count + 1 | 0;
+      continue;
+    } else {
+      return count === len && index === end_offset$2;
+    }
+  }
+}
+function moonbitlang$core$string$$String$substring$46$inner(self, start, end) {
+  const len = self.length;
+  let end$2;
+  if (end === undefined) {
+    end$2 = len;
+  } else {
+    const _Some = end;
+    end$2 = _Some;
+  }
+  return start >= 0 && (start <= end$2 && end$2 <= len) ? self.substring(start, end$2) : $panic();
+}
+function moonbitlang$core$builtin$$Logger$write_substring$6$(self, str, start, len) {
+  const _bind = self;
+  _bind.val = `${_bind.val}${moonbitlang$core$string$$String$substring$46$inner(str, start, start + len | 0)}`;
+}
+function moonbitlang$core$array$$Array$new$46$inner$14$(capacity) {
+  return [];
+}
+function moonbitlang$core$array$$Array$new$46$inner$15$(capacity) {
+  return [];
+}
+function moonbitlang$core$array$$Array$new$46$inner$2$(capacity) {
+  return [];
+}
+function moonbitlang$core$array$$Array$push$15$(self, value) {
+  moonbitlang$core$builtin$$JSArray$push(self, value);
+}
+function moonbitlang$core$array$$Array$push$14$(self, value) {
+  moonbitlang$core$builtin$$JSArray$push(self, value);
+}
+function moonbitlang$core$array$$Array$push$2$(self, value) {
+  moonbitlang$core$builtin$$JSArray$push(self, value);
+}
+function moonbitlang$core$array$$Array$push$5$(self, value) {
+  moonbitlang$core$builtin$$JSArray$push(self, value);
+}
+function moonbitlang$core$array$$Array$push$7$(self, value) {
+  moonbitlang$core$builtin$$JSArray$push(self, value);
+}
+function moonbitlang$core$builtin$$Show$to_string$16$(self) {
+  return String.fromCodePoint(self);
+}
+function moonbitlang$core$builtin$$Iter$each$17$(self, f) {
+  const _foreach_result = { val: $64$moonbitlang$47$core$47$builtin$46$ForeachResult$Continue$0$ };
+  self((a) => {
+    f(a);
+    return 1;
+  });
+  const _tmp = _foreach_result.val;
+  switch (_tmp.$tag) {
+    case 0: {
+      return;
+    }
+    case 1: {
+      const _break = _tmp;
+      _break._0;
+      return;
+    }
+    case 2: {
+      const _return = _tmp;
+      return _return._0;
+    }
+    case 3: {
+      $panic();
+      return;
+    }
+    default: {
+      $panic();
+      return;
+    }
+  }
+}
+function moonbitlang$core$builtin$$Iter$collect$2$(self) {
+  const result = [];
+  moonbitlang$core$builtin$$Iter$each$17$(self, (e) => {
+    moonbitlang$core$array$$Array$push$2$(result, e);
+  });
+  return result;
+}
+function moonbitlang$core$builtin$$Iterator$next$2$(self) {
+  const _func = self;
+  return _func();
+}
+function moonbitlang$core$builtin$$Show$output$13$(self, logger) {
+  logger.method_0(logger.self, moonbitlang$core$int$$Int$to_string$46$inner(self, 10));
+}
+function moonbitlang$core$array$$Array$iter$7$(self) {
+  const _p = (yield_) => {
+    const _len = self.length;
+    let _tmp = 0;
+    while (true) {
+      const _i = _tmp;
+      if (_i < _len) {
+        const v = self[_i];
+        const _bind = yield_(v);
+        if (_bind === 1) {
+        } else {
+          return 0;
+        }
+        _tmp = _i + 1 | 0;
+        continue;
+      } else {
+        return 1;
+      }
+    }
+  };
+  return _p;
+}
+function moonbitlang$core$array$$FixedArray$sub$46$inner$2$(self, start, end) {
+  const len = self.length;
+  let end$2;
+  if (end === undefined) {
+    end$2 = len;
+  } else {
+    const _Some = end;
+    const _end = _Some;
+    end$2 = _end < 0 ? len + _end | 0 : _end;
+  }
+  const start$2 = start < 0 ? len + start | 0 : start;
+  return start$2 >= 0 && (start$2 <= end$2 && end$2 <= len) ? { buf: self, start: start$2, end: end$2 } : moonbitlang$core$abort$$abort$4$("View index out of bounds");
+}
+function moonbitlang$core$builtin$$MyInt64$extend_i32_u(value) {
+  return { hi: 0, lo: value };
+}
+function moonbitlang$core$uint64$$UInt64$extend_uint(value) {
+  return moonbitlang$core$builtin$$MyInt64$extend_i32_u(value);
+}
+function moonbitlang$core$uint$$UInt$to_uint64(self) {
+  return moonbitlang$core$uint64$$UInt64$extend_uint(self);
+}
+function moonbitlang$core$int64$$Int64$reinterpret_as_double(self) {
+  return moonbitlang$core$builtin$$MyInt64$reinterpret_as_double(self);
+}
+function moonbitlang$core$builtin$$MyInt64$from_int(value) {
+  return { hi: value >> 31 & -1, lo: value | 0 };
+}
+function moonbitlang$core$int$$Int$to_int64(self) {
+  return moonbitlang$core$builtin$$MyInt64$from_int(self);
+}
+function moonbitlang$core$uint64$$UInt64$to_int(self) {
+  const _p = self;
+  return _p.lo;
+}
+function moonbitlang$core$uint64$$UInt64$to_byte(self) {
+  return moonbitlang$core$uint64$$UInt64$to_int(self) & 255;
+}
+function moonbitlang$core$builtin$$MyInt64$land(self, other) {
+  return { hi: self.hi & other.hi, lo: self.lo & other.lo };
+}
+function moonbitlang$core$builtin$$MyInt64$lor(self, other) {
+  return { hi: self.hi | other.hi, lo: self.lo | other.lo };
+}
+function moonbitlang$core$builtin$$MyInt64$lxor(self, other) {
+  return { hi: self.hi ^ other.hi, lo: self.lo ^ other.lo };
+}
+function moonbitlang$core$builtin$$MyInt64$lsl(self, shift) {
+  const shift$2 = shift & 63;
+  if (shift$2 === 0) {
+    return self;
+  } else {
+    if (shift$2 < 32) {
+      const _hi = self.hi;
+      const _lo = self.lo;
+      const hi = _hi;
+      const lo = _lo;
+      const hi$2 = hi << shift$2 | (lo >>> (32 - shift$2 | 0) | 0);
+      const lo$2 = lo << shift$2;
+      return { hi: hi$2, lo: lo$2 };
+    } else {
+      return { hi: self.lo << (shift$2 - 32 | 0), lo: 0 };
+    }
+  }
+}
+function moonbitlang$core$builtin$$MyInt64$lsr(self, shift) {
+  const shift$2 = shift & 63;
+  return shift$2 === 0 ? self : shift$2 < 32 ? { hi: self.hi >>> shift$2 | 0, lo: self.lo >>> shift$2 | self.hi << (32 - shift$2 | 0) } : { hi: 0, lo: self.hi >>> (shift$2 - 32 | 0) | 0 };
+}
+function moonbitlang$core$builtin$$BitOr$lor$9$(self, other) {
+  return moonbitlang$core$builtin$$MyInt64$lor(self, other);
+}
+function moonbitlang$core$builtin$$Shl$shl$9$(self, other) {
+  return moonbitlang$core$builtin$$MyInt64$lsl(self, other);
+}
+function moonbitlang$core$double$$Double$convert_int64(value) {
+  return moonbitlang$core$builtin$$MyInt64$convert_to_double(value);
+}
+function moonbitlang$core$int64$$Int64$to_double(self) {
+  return moonbitlang$core$double$$Double$convert_int64(self);
+}
+function moonbitlang$core$uint64$$UInt64$reinterpret_as_double(self) {
+  return moonbitlang$core$builtin$$MyInt64$reinterpret_as_double(self);
+}
+function moonbitlang$core$double$$Double$reinterpret_as_uint64(self) {
+  return moonbitlang$core$builtin$$MyInt64$reinterpret_double(self);
+}
+function moonbitlang$core$builtin$$Eq$equal$18$(self, other) {
+  const _p = self;
+  const _p$2 = other;
+  return _p.hi === _p$2.hi && _p.lo === _p$2.lo;
+}
+function moonbitlang$core$builtin$$BitAnd$land$18$(self, other) {
+  return moonbitlang$core$builtin$$MyInt64$land(self, other);
+}
+function moonbitlang$core$builtin$$BitOr$lor$18$(self, other) {
+  return moonbitlang$core$builtin$$MyInt64$lor(self, other);
+}
+function moonbitlang$core$builtin$$BitXOr$lxor$18$(self, other) {
+  return moonbitlang$core$builtin$$MyInt64$lxor(self, other);
+}
+function moonbitlang$core$builtin$$Shl$shl$18$(self, shift) {
+  return moonbitlang$core$builtin$$MyInt64$lsl(self, shift);
+}
+function moonbitlang$core$builtin$$Shr$shr$18$(self, shift) {
+  return moonbitlang$core$builtin$$MyInt64$lsr(self, shift);
+}
+function moonbitlang$core$double$$Double$to_int64(self) {
+  return moonbitlang$core$builtin$$MyInt64$from_double(self);
+}
+function moonbitlang$core$bytes$$Bytes$makei$11$(length, value) {
+  if (length <= 0) {
+    return $bytes_literal$0;
+  }
+  const arr = $makebytes(length, value(0));
+  let _tmp = 1;
+  while (true) {
+    const i = _tmp;
+    if (i < length) {
+      $bound_check(arr, i);
+      arr[i] = value(i);
+      _tmp = i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  return arr;
+}
+function moonbitlang$core$builtin$$println$5$(input) {
+  console.log(input);
+}
+function moonbitlang$core$array$$FixedArray$blit_from_bytes(self, bytes_offset, src, src_offset, length) {
+  const e1 = (bytes_offset + length | 0) - 1 | 0;
+  const e2 = (src_offset + length | 0) - 1 | 0;
+  const len1 = self.length;
+  const len2 = src.length;
+  if (length >= 0 && (bytes_offset >= 0 && (e1 < len1 && (src_offset >= 0 && e2 < len2)))) {
+    moonbitlang$core$array$$FixedArray$unsafe_blit$2$(self, bytes_offset, src, src_offset, length);
+    return;
+  } else {
+    $panic();
+    return;
+  }
+}
+function moonbitlang$core$array$$ArrayView$at$2$(self, index) {
+  if (index >= 0 && index < (self.end - self.start | 0)) {
+    const _tmp = self.buf;
+    const _tmp$2 = self.start + index | 0;
+    $bound_check(_tmp, _tmp$2);
+    return _tmp[_tmp$2];
+  } else {
+    return moonbitlang$core$abort$$abort$2$(`index out of bounds: the len is from 0 to ${moonbitlang$core$builtin$$Show$to_string$10$(self.end - self.start | 0)} but the index is ${moonbitlang$core$builtin$$Show$to_string$10$(index)}`);
+  }
+}
+function moonbitlang$core$array$$Array$rev$2$(self) {
+  const len = self.length;
+  const arr = new Array(len);
+  let _tmp = 0;
+  while (true) {
+    const i = _tmp;
+    if (i < len) {
+      arr[i] = self[(len - i | 0) - 1 | 0];
+      _tmp = i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  return arr;
+}
+function moonbitlang$core$buffer$$Buffer$grow_if_necessary(self, required) {
+  const start = self.data.length <= 0 ? 1 : self.data.length;
+  let enough_space;
+  let _tmp = start;
+  while (true) {
+    const space = _tmp;
+    if (space >= required) {
+      enough_space = space;
+      break;
+    }
+    _tmp = Math.imul(space, 2) | 0;
+    continue;
+  }
+  if (enough_space !== self.data.length) {
+    const new_data = $makebytes(enough_space, 0);
+    moonbitlang$core$array$$FixedArray$unsafe_blit$2$(new_data, 0, self.data, 0, self.len);
+    self.data = new_data;
+    return;
+  } else {
+    return;
+  }
+}
+function moonbitlang$core$buffer$$Buffer$write_byte(self, value) {
+  moonbitlang$core$buffer$$Buffer$grow_if_necessary(self, self.len + 1 | 0);
+  const _tmp = self.data;
+  const _tmp$2 = self.len;
+  $bound_check(_tmp, _tmp$2);
+  _tmp[_tmp$2] = value;
+  self.len = self.len + 1 | 0;
+}
+function moonbitlang$core$buffer$$Buffer$contents(self) {
+  return moonbitlang$core$bytes$$Bytes$from_array(moonbitlang$core$array$$FixedArray$sub$46$inner$2$(self.data, 0, self.len));
+}
+function moonbitlang$core$buffer$$new$46$inner(size_hint) {
+  const initial = size_hint < 1 ? 1 : size_hint;
+  const data = $makebytes(initial, 0);
+  return { data: data, len: 0 };
+}
+function moonbitlang$core$buffer$$Buffer$write_bytes(self, value) {
+  const val_len = value.length;
+  moonbitlang$core$buffer$$Buffer$grow_if_necessary(self, self.len + val_len | 0);
+  moonbitlang$core$array$$FixedArray$blit_from_bytes(self.data, self.len, value, 0, val_len);
+  self.len = self.len + val_len | 0;
+}
+function zxch3n$expect$$Color$to_bg_color_code(self) {
+  switch (self) {
+    case 0: {
+      return "40";
+    }
+    case 1: {
+      return "41";
+    }
+    case 2: {
+      return "42";
+    }
+    case 3: {
+      return "43";
+    }
+    case 4: {
+      return "44";
+    }
+    case 5: {
+      return "45";
+    }
+    case 6: {
+      return "46";
+    }
+    case 7: {
+      return "47";
+    }
+    default: {
+      return "49";
+    }
+  }
+}
+function zxch3n$expect$$Color$to_color_code(self) {
+  switch (self) {
+    case 0: {
+      return "30";
+    }
+    case 1: {
+      return "31";
+    }
+    case 2: {
+      return "32";
+    }
+    case 3: {
+      return "33";
+    }
+    case 4: {
+      return "34";
+    }
+    case 5: {
+      return "35";
+    }
+    case 6: {
+      return "36";
+    }
+    case 7: {
+      return "37";
+    }
+    default: {
+      return "39";
+    }
+  }
+}
+function zxch3n$expect$$Formated$to_string(self) {
+  const styles = [];
+  const _bind = self.color;
+  if (_bind === undefined) {
+  } else {
+    const _Some = _bind;
+    const _color = _Some;
+    moonbitlang$core$array$$Array$push$5$(styles, zxch3n$expect$$Color$to_color_code(_color));
+  }
+  const _bind$2 = self.bg_color;
+  if (_bind$2 === undefined) {
+  } else {
+    const _Some = _bind$2;
+    const _bg_color = _Some;
+    moonbitlang$core$array$$Array$push$5$(styles, zxch3n$expect$$Color$to_bg_color_code(_bg_color));
+  }
+  const _arr = self.formats;
+  const _len = _arr.length;
+  let _tmp = 0;
+  while (true) {
+    const _i = _tmp;
+    if (_i < _len) {
+      const format = _arr[_i];
+      switch (format) {
+        case 0: {
+          moonbitlang$core$array$$Array$push$5$(styles, "1");
+          break;
+        }
+        case 1: {
+          moonbitlang$core$array$$Array$push$5$(styles, "4");
+          break;
+        }
+        case 2: {
+          moonbitlang$core$array$$Array$push$5$(styles, "5");
+          break;
+        }
+        case 3: {
+          moonbitlang$core$array$$Array$push$5$(styles, "7");
+          break;
+        }
+        case 4: {
+          moonbitlang$core$array$$Array$push$5$(styles, "8");
+          break;
+        }
+        case 5: {
+          moonbitlang$core$array$$Array$push$5$(styles, "9");
+          break;
+        }
+        default: {
+          moonbitlang$core$array$$Array$push$5$(styles, "3");
+        }
+      }
+      _tmp = _i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  if (styles.length > 0) {
+    const style_string = moonbitlang$core$array$$Array$join$5$(styles, { str: zxch3n$expect$$to_string$46$42$bind$124$178, start: 0, end: zxch3n$expect$$to_string$46$42$bind$124$178.length });
+    return `[${style_string}m${self.str}[0m`;
+  } else {
+    return self.str;
+  }
+}
+function zxch3n$expect$$Formated$format(str) {
+  return { str: str, bg_color: undefined, color: undefined, formats: [] };
+}
+function zxch3n$expect$$Formated$red(self) {
+  return { str: self.str, bg_color: self.bg_color, color: zxch3n$expect$$red$46$constr$47$350, formats: self.formats };
+}
+function zxch3n$expect$$Formated$yellow(self) {
+  return { str: self.str, bg_color: self.bg_color, color: zxch3n$expect$$yellow$46$constr$47$352, formats: self.formats };
+}
+function zxch3n$expect$$Formated$blue(self) {
+  return { str: self.str, bg_color: self.bg_color, color: zxch3n$expect$$blue$46$constr$47$354, formats: self.formats };
+}
+function zxch3n$expect$$Formated$bold(self) {
+  const _tmp = self.str;
+  const _tmp$2 = self.bg_color;
+  const _tmp$3 = self.color;
+  const _self = [];
+  moonbitlang$core$array$$Array$push$7$(_self, 0);
+  moonbitlang$core$array$$Array$push_iter$7$(_self, moonbitlang$core$array$$Array$iter$7$(self.formats));
+  return { str: _tmp, bg_color: _tmp$2, color: _tmp$3, formats: _self };
+}
+function zxch3n$expect$$panic$46$inner$3$(reason, loc) {
+  const msg = `${zxch3n$expect$$Formated$to_string(zxch3n$expect$$Formated$red(zxch3n$expect$$Formated$bold(zxch3n$expect$$Formated$format("Panic: "))))}${zxch3n$expect$$Formated$to_string(zxch3n$expect$$Formated$yellow(zxch3n$expect$$Formated$format(reason)))} at ${zxch3n$expect$$Formated$to_string(zxch3n$expect$$Formated$blue(zxch3n$expect$$Formated$format(loc)))}`;
+  moonbitlang$core$builtin$$println$5$(msg);
+  moonbitlang$core$abort$$abort$3$(msg);
+}
+function zxch3n$flock$types$$string_to_utf8(str) {
+  const bytes = moonbitlang$core$array$$Array$new$46$inner$2$(0);
+  let i = 0;
+  while (true) {
+    if (i < str.length) {
+      const _tmp = i;
+      $bound_check(str, _tmp);
+      const code = str.charCodeAt(_tmp);
+      if (code >= 55296 && (code <= 56319 && (i + 1 | 0) < str.length)) {
+        const _tmp$2 = i + 1 | 0;
+        $bound_check(str, _tmp$2);
+        const low = str.charCodeAt(_tmp$2);
+        if (low >= 56320 && low <= 57343) {
+          const code_point = (65536 + (code - 55296 << 10) | 0) + (low - 56320 | 0) | 0;
+          moonbitlang$core$array$$Array$push$2$(bytes, (240 | code_point >> 18) & 255);
+          moonbitlang$core$array$$Array$push$2$(bytes, (128 | code_point >> 12 & 63) & 255);
+          moonbitlang$core$array$$Array$push$2$(bytes, (128 | code_point >> 6 & 63) & 255);
+          moonbitlang$core$array$$Array$push$2$(bytes, (128 | code_point & 63) & 255);
+          i = i + 1 | 0;
+        } else {
+          moonbitlang$core$array$$Array$push$2$(bytes, (224 | code >> 12) & 255);
+          moonbitlang$core$array$$Array$push$2$(bytes, (128 | code >> 6 & 63) & 255);
+          moonbitlang$core$array$$Array$push$2$(bytes, (128 | code & 63) & 255);
+        }
+      } else {
+        if (code < 128) {
+          moonbitlang$core$array$$Array$push$2$(bytes, code & 255);
+        } else {
+          if (code < 2048) {
+            moonbitlang$core$array$$Array$push$2$(bytes, (192 | code >> 6) & 255);
+            moonbitlang$core$array$$Array$push$2$(bytes, (128 | code & 63) & 255);
+          } else {
+            moonbitlang$core$array$$Array$push$2$(bytes, (224 | code >> 12) & 255);
+            moonbitlang$core$array$$Array$push$2$(bytes, (128 | code >> 6 & 63) & 255);
+            moonbitlang$core$array$$Array$push$2$(bytes, (128 | code & 63) & 255);
+          }
+        }
+      }
+      i = i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  return moonbitlang$core$bytes$$Bytes$from_array({ buf: bytes, start: 0, end: bytes.length });
+}
+function zxch3n$flock$types$$Utf8Str$from_string(str) {
+  return { bytes: zxch3n$flock$types$$string_to_utf8(str) };
+}
+function zxch3n$flock$types$$is_valid_utf8(utf8Arr) {
+  let i = 0;
+  while (true) {
+    if (i < (utf8Arr.end - utf8Arr.start | 0)) {
+      const byte = moonbitlang$core$bytes$$BytesView$at(utf8Arr, i);
+      const _p = 128;
+      const _p$2 = byte & _p & 255;
+      const _p$3 = 0;
+      if (_p$2 === _p$3) {
+        i = i + 1 | 0;
+      } else {
+        const _p$4 = 224;
+        const _p$5 = byte & _p$4 & 255;
+        const _p$6 = 192;
+        if (_p$5 === _p$6) {
+          if ((i + 1 | 0) >= (utf8Arr.end - utf8Arr.start | 0)) {
+            return false;
+          }
+          const byte2 = moonbitlang$core$bytes$$BytesView$at(utf8Arr, i + 1 | 0);
+          const _p$7 = 192;
+          if ((byte2 & _p$7 & 255) !== 128) {
+            return false;
+          }
+          i = i + 2 | 0;
+        } else {
+          const _p$7 = 240;
+          const _p$8 = byte & _p$7 & 255;
+          const _p$9 = 224;
+          if (_p$8 === _p$9) {
+            if ((i + 2 | 0) >= (utf8Arr.end - utf8Arr.start | 0)) {
+              return false;
+            }
+            const byte2 = moonbitlang$core$bytes$$BytesView$at(utf8Arr, i + 1 | 0);
+            const byte3 = moonbitlang$core$bytes$$BytesView$at(utf8Arr, i + 2 | 0);
+            let _tmp;
+            const _p$10 = 192;
+            if ((byte2 & _p$10 & 255) !== 128) {
+              _tmp = true;
+            } else {
+              const _p$11 = 192;
+              _tmp = (byte3 & _p$11 & 255) !== 128;
+            }
+            if (_tmp) {
+              return false;
+            }
+            i = i + 3 | 0;
+          } else {
+            const _p$10 = 248;
+            const _p$11 = byte & _p$10 & 255;
+            const _p$12 = 240;
+            if (_p$11 === _p$12) {
+              if ((i + 3 | 0) >= (utf8Arr.end - utf8Arr.start | 0)) {
+                return false;
+              }
+              const byte2 = moonbitlang$core$bytes$$BytesView$at(utf8Arr, i + 1 | 0);
+              const byte3 = moonbitlang$core$bytes$$BytesView$at(utf8Arr, i + 2 | 0);
+              const byte4 = moonbitlang$core$bytes$$BytesView$at(utf8Arr, i + 3 | 0);
+              let _tmp;
+              const _p$13 = 192;
+              if ((byte2 & _p$13 & 255) !== 128) {
+                _tmp = true;
+              } else {
+                let _tmp$2;
+                const _p$14 = 192;
+                if ((byte3 & _p$14 & 255) !== 128) {
+                  _tmp$2 = true;
+                } else {
+                  const _p$15 = 192;
+                  _tmp$2 = (byte4 & _p$15 & 255) !== 128;
+                }
+                _tmp = _tmp$2;
+              }
+              if (_tmp) {
+                return false;
+              }
+              i = i + 4 | 0;
+            } else {
+              return false;
+            }
+          }
+        }
+      }
+      continue;
+    } else {
+      break;
+    }
+  }
+  return true;
+}
+function zxch3n$flock$types$$Utf8Str$from_bytes_view(bytes) {
+  if (!zxch3n$flock$types$$is_valid_utf8(moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, 0, undefined))) {
+    return undefined;
+  }
+  return { bytes: moonbitlang$core$bytes$$Bytes$from_iter(moonbitlang$core$bytes$$BytesView$iter(bytes)) };
+}
+function zxch3n$flock$types$$new_string_from_utf8(utf8Arr) {
+  let i = 0;
+  let result = "";
+  while (true) {
+    if (i < utf8Arr.length) {
+      const _tmp = i;
+      $bound_check(utf8Arr, _tmp);
+      const byte = utf8Arr[_tmp];
+      let code_point;
+      const _p = 128;
+      const _p$2 = byte & _p & 255;
+      const _p$3 = 0;
+      if (_p$2 === _p$3) {
+        code_point = byte;
+      } else {
+        const _p$4 = 224;
+        const _p$5 = byte & _p$4 & 255;
+        const _p$6 = 192;
+        if (_p$5 === _p$6) {
+          if ((i + 1 | 0) >= utf8Arr.length) {
+            return undefined;
+          }
+          const _tmp$2 = i + 1 | 0;
+          $bound_check(utf8Arr, _tmp$2);
+          const byte2 = utf8Arr[_tmp$2];
+          const _p$7 = 192;
+          if ((byte2 & _p$7 & 255) !== 128) {
+            return undefined;
+          }
+          i = i + 1 | 0;
+          const _p$8 = 31;
+          const _tmp$3 = (byte & _p$8 & 255) << 6;
+          const _p$9 = 63;
+          code_point = _tmp$3 | byte2 & _p$9 & 255;
+        } else {
+          const _p$7 = 240;
+          const _p$8 = byte & _p$7 & 255;
+          const _p$9 = 224;
+          if (_p$8 === _p$9) {
+            if ((i + 2 | 0) >= utf8Arr.length) {
+              return undefined;
+            }
+            const _tmp$2 = i + 1 | 0;
+            $bound_check(utf8Arr, _tmp$2);
+            const byte2 = utf8Arr[_tmp$2];
+            const _tmp$3 = i + 2 | 0;
+            $bound_check(utf8Arr, _tmp$3);
+            const byte3 = utf8Arr[_tmp$3];
+            let _tmp$4;
+            const _p$10 = 192;
+            if ((byte2 & _p$10 & 255) !== 128) {
+              _tmp$4 = true;
+            } else {
+              const _p$11 = 192;
+              _tmp$4 = (byte3 & _p$11 & 255) !== 128;
+            }
+            if (_tmp$4) {
+              return undefined;
+            }
+            i = i + 2 | 0;
+            const _p$11 = 15;
+            const _tmp$5 = (byte & _p$11 & 255) << 12;
+            const _p$12 = 63;
+            const _tmp$6 = _tmp$5 | (byte2 & _p$12 & 255) << 6;
+            const _p$13 = 63;
+            code_point = _tmp$6 | byte3 & _p$13 & 255;
+          } else {
+            const _p$10 = 248;
+            const _p$11 = byte & _p$10 & 255;
+            const _p$12 = 240;
+            if (_p$11 === _p$12) {
+              if ((i + 3 | 0) >= utf8Arr.length) {
+                return undefined;
+              }
+              const _tmp$2 = i + 1 | 0;
+              $bound_check(utf8Arr, _tmp$2);
+              const byte2 = utf8Arr[_tmp$2];
+              const _tmp$3 = i + 2 | 0;
+              $bound_check(utf8Arr, _tmp$3);
+              const byte3 = utf8Arr[_tmp$3];
+              const _tmp$4 = i + 3 | 0;
+              $bound_check(utf8Arr, _tmp$4);
+              const byte4 = utf8Arr[_tmp$4];
+              let _tmp$5;
+              const _p$13 = 192;
+              if ((byte2 & _p$13 & 255) !== 128) {
+                _tmp$5 = true;
+              } else {
+                let _tmp$6;
+                const _p$14 = 192;
+                if ((byte3 & _p$14 & 255) !== 128) {
+                  _tmp$6 = true;
+                } else {
+                  const _p$15 = 192;
+                  _tmp$6 = (byte4 & _p$15 & 255) !== 128;
+                }
+                _tmp$5 = _tmp$6;
+              }
+              if (_tmp$5) {
+                return undefined;
+              }
+              i = i + 3 | 0;
+              const _p$14 = 7;
+              const _tmp$6 = (byte & _p$14 & 255) << 18;
+              const _p$15 = 63;
+              const _tmp$7 = _tmp$6 | (byte2 & _p$15 & 255) << 12;
+              const _p$16 = 63;
+              const _tmp$8 = _tmp$7 | (byte3 & _p$16 & 255) << 6;
+              const _p$17 = 63;
+              code_point = _tmp$8 | byte4 & _p$17 & 255;
+            } else {
+              return undefined;
+            }
+          }
+        }
+      }
+      result = `${result}${moonbitlang$core$builtin$$Show$to_string$16$(code_point)}`;
+      i = i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+function zxch3n$flock$types$$Utf8Str$to_string(self) {
+  const _p = zxch3n$flock$types$$new_string_from_utf8(self.bytes);
+  if (_p === undefined) {
+    return $panic();
+  } else {
+    const _p$2 = _p;
+    return _p$2;
+  }
+}
+function zxch3n$flock$memcomparable$$double_to_bits(d) {
+  return moonbitlang$core$double$$Double$reinterpret_as_uint64(d);
+}
+function zxch3n$flock$memcomparable$$double_from_bits(bits) {
+  return moonbitlang$core$uint64$$UInt64$reinterpret_as_double(bits);
+}
+function zxch3n$flock$memcomparable$$uint64_to_be_bytes(n) {
+  const bytes = moonbitlang$core$array$$Array$new$46$inner$2$(0);
+  moonbitlang$core$array$$Array$push$2$(bytes, moonbitlang$core$uint64$$UInt64$to_byte(moonbitlang$core$builtin$$BitAnd$land$18$(moonbitlang$core$builtin$$Shr$shr$18$(n, 56), $255L)));
+  moonbitlang$core$array$$Array$push$2$(bytes, moonbitlang$core$uint64$$UInt64$to_byte(moonbitlang$core$builtin$$BitAnd$land$18$(moonbitlang$core$builtin$$Shr$shr$18$(n, 48), $255L)));
+  moonbitlang$core$array$$Array$push$2$(bytes, moonbitlang$core$uint64$$UInt64$to_byte(moonbitlang$core$builtin$$BitAnd$land$18$(moonbitlang$core$builtin$$Shr$shr$18$(n, 40), $255L)));
+  moonbitlang$core$array$$Array$push$2$(bytes, moonbitlang$core$uint64$$UInt64$to_byte(moonbitlang$core$builtin$$BitAnd$land$18$(moonbitlang$core$builtin$$Shr$shr$18$(n, 32), $255L)));
+  moonbitlang$core$array$$Array$push$2$(bytes, moonbitlang$core$uint64$$UInt64$to_byte(moonbitlang$core$builtin$$BitAnd$land$18$(moonbitlang$core$builtin$$Shr$shr$18$(n, 24), $255L)));
+  moonbitlang$core$array$$Array$push$2$(bytes, moonbitlang$core$uint64$$UInt64$to_byte(moonbitlang$core$builtin$$BitAnd$land$18$(moonbitlang$core$builtin$$Shr$shr$18$(n, 16), $255L)));
+  moonbitlang$core$array$$Array$push$2$(bytes, moonbitlang$core$uint64$$UInt64$to_byte(moonbitlang$core$builtin$$BitAnd$land$18$(moonbitlang$core$builtin$$Shr$shr$18$(n, 8), $255L)));
+  moonbitlang$core$array$$Array$push$2$(bytes, moonbitlang$core$uint64$$UInt64$to_byte(moonbitlang$core$builtin$$BitAnd$land$18$(n, $255L)));
+  return moonbitlang$core$bytes$$Bytes$from_array({ buf: bytes, start: 0, end: bytes.length });
+}
+function zxch3n$flock$memcomparable$$uint64_from_be_bytes(bytes) {
+  if (bytes.length !== 8) {
+    zxch3n$expect$$panic$46$inner$3$("Invalid byte array length", "/Users/zxch3n/Code/flock/moon/memcomparable/utils.mbt:28:5-28:54");
+  }
+  let result = $0L;
+  const _tmp = result;
+  $bound_check(bytes, 0);
+  result = moonbitlang$core$builtin$$BitOr$lor$18$(_tmp, moonbitlang$core$builtin$$Shl$shl$18$(moonbitlang$core$byte$$Byte$to_uint64(bytes[0]), 56));
+  const _tmp$2 = result;
+  $bound_check(bytes, 1);
+  result = moonbitlang$core$builtin$$BitOr$lor$18$(_tmp$2, moonbitlang$core$builtin$$Shl$shl$18$(moonbitlang$core$byte$$Byte$to_uint64(bytes[1]), 48));
+  const _tmp$3 = result;
+  $bound_check(bytes, 2);
+  result = moonbitlang$core$builtin$$BitOr$lor$18$(_tmp$3, moonbitlang$core$builtin$$Shl$shl$18$(moonbitlang$core$byte$$Byte$to_uint64(bytes[2]), 40));
+  const _tmp$4 = result;
+  $bound_check(bytes, 3);
+  result = moonbitlang$core$builtin$$BitOr$lor$18$(_tmp$4, moonbitlang$core$builtin$$Shl$shl$18$(moonbitlang$core$byte$$Byte$to_uint64(bytes[3]), 32));
+  const _tmp$5 = result;
+  $bound_check(bytes, 4);
+  result = moonbitlang$core$builtin$$BitOr$lor$18$(_tmp$5, moonbitlang$core$builtin$$Shl$shl$18$(moonbitlang$core$byte$$Byte$to_uint64(bytes[4]), 24));
+  const _tmp$6 = result;
+  $bound_check(bytes, 5);
+  result = moonbitlang$core$builtin$$BitOr$lor$18$(_tmp$6, moonbitlang$core$builtin$$Shl$shl$18$(moonbitlang$core$byte$$Byte$to_uint64(bytes[5]), 16));
+  const _tmp$7 = result;
+  $bound_check(bytes, 6);
+  result = moonbitlang$core$builtin$$BitOr$lor$18$(_tmp$7, moonbitlang$core$builtin$$Shl$shl$18$(moonbitlang$core$byte$$Byte$to_uint64(bytes[6]), 8));
+  const _tmp$8 = result;
+  $bound_check(bytes, 7);
+  result = moonbitlang$core$builtin$$BitOr$lor$18$(_tmp$8, moonbitlang$core$byte$$Byte$to_uint64(bytes[7]));
+  return result;
+}
+function zxch3n$flock$memcomparable$$Key$new() {
+  return { parts: moonbitlang$core$array$$Array$new$46$inner$15$(0) };
+}
+function zxch3n$flock$memcomparable$$Key$push(self, part) {
+  moonbitlang$core$array$$Array$push$15$(self.parts, part);
+}
+function zxch3n$flock$memcomparable$$canonicalize_f64(n) {
+  return n !== n ? (n < 0 ? -moonbitlang$core$double$$not_a_number : moonbitlang$core$double$$not_a_number) : n;
+}
+function zxch3n$flock$memcomparable$$encode_bytes(bytes, output) {
+  moonbitlang$core$buffer$$Buffer$write_byte(output, 1);
+  const _it = moonbitlang$core$bytes$$BytesView$iterator(bytes);
+  while (true) {
+    const _bind = moonbitlang$core$builtin$$Iterator$next$2$(_it);
+    if (_bind === -1) {
+      break;
+    } else {
+      const _Some = _bind;
+      const _b = _Some;
+      moonbitlang$core$buffer$$Buffer$write_byte(output, _b);
+      const _p = 0;
+      if (_b === _p) {
+        moonbitlang$core$buffer$$Buffer$write_byte(output, 255);
+      }
+      continue;
+    }
+  }
+  moonbitlang$core$buffer$$Buffer$write_byte(output, 0);
+}
+function zxch3n$flock$memcomparable$$encode_string(s, output) {
+  moonbitlang$core$buffer$$Buffer$write_byte(output, 2);
+  const bytes = s.bytes;
+  const _len = bytes.length;
+  let _tmp = 0;
+  while (true) {
+    const _i = _tmp;
+    if (_i < _len) {
+      const b = bytes[_i];
+      moonbitlang$core$buffer$$Buffer$write_byte(output, b);
+      const _p = 0;
+      if (b === _p) {
+        moonbitlang$core$buffer$$Buffer$write_byte(output, 255);
+      }
+      _tmp = _i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  moonbitlang$core$buffer$$Buffer$write_byte(output, 0);
+}
+function zxch3n$flock$memcomparable$$encode_float(f, output) {
+  moonbitlang$core$buffer$$Buffer$write_byte(output, 33);
+  const f$2 = zxch3n$flock$memcomparable$$canonicalize_f64(f);
+  const bits = f$2 < 0 ? moonbitlang$core$builtin$$BitXOr$lxor$18$(zxch3n$flock$memcomparable$$double_to_bits(f$2), $_1L) : moonbitlang$core$builtin$$BitXOr$lxor$18$(zxch3n$flock$memcomparable$$double_to_bits(f$2), $_9223372036854775808L);
+  const bytes = zxch3n$flock$memcomparable$$uint64_to_be_bytes(bits);
+  const _len = bytes.length;
+  let _tmp = 0;
+  while (true) {
+    const _i = _tmp;
+    if (_i < _len) {
+      const b = bytes[_i];
+      moonbitlang$core$buffer$$Buffer$write_byte(output, b);
+      _tmp = _i + 1 | 0;
+      continue;
+    } else {
+      return;
+    }
+  }
+}
+function zxch3n$flock$memcomparable$$biguint_to_be_bytes(n) {
+  const bytes = [];
+  let x = n;
+  while (true) {
+    if (moonbitlang$core$builtin$$Compare$op_gt$12$(x, 0n)) {
+      const byte = moonbitlang$core$bigint$$BigInt$to_int(moonbitlang$core$builtin$$Mod$mod$8$(x, 256n));
+      moonbitlang$core$array$$Array$push$2$(bytes, byte & 255);
+      x = moonbitlang$core$builtin$$Div$div$8$(x, 256n);
+      continue;
+    } else {
+      break;
+    }
+  }
+  const _bind = moonbitlang$core$array$$Array$rev$2$(bytes);
+  return moonbitlang$core$bytes$$Bytes$from_array({ buf: _bind, start: 0, end: _bind.length });
+}
+function zxch3n$flock$memcomparable$$bigint_to_be_bytes(n, output) {
+  if (moonbitlang$core$builtin$$Eq$equal$8$(n, 0n)) {
+    moonbitlang$core$buffer$$Buffer$write_byte(output, 20);
+    return undefined;
+  }
+  const sign = moonbitlang$core$builtin$$Compare$op_gt$12$(n, 0n);
+  const bytes = sign ? zxch3n$flock$memcomparable$$biguint_to_be_bytes(n) : zxch3n$flock$memcomparable$$biguint_to_be_bytes(moonbitlang$core$builtin$$Neg$neg$8$(n));
+  const n$2 = bytes.length;
+  if (sign === false) {
+    if (n$2 <= 8) {
+      const _p = 20;
+      const _p$2 = n$2 & 255;
+      moonbitlang$core$buffer$$Buffer$write_byte(output, (_p - _p$2 | 0) & 255);
+    } else {
+      moonbitlang$core$buffer$$Buffer$write_byte(output, 11);
+      if (n$2 > 255) {
+        moonbitlang$core$abort$$abort$3$("n is too large");
+      }
+      const _p = n$2 & 255;
+      const _p$2 = 255;
+      moonbitlang$core$buffer$$Buffer$write_byte(output, (_p ^ _p$2) & 255);
+    }
+    const inverted = moonbitlang$core$buffer$$new$46$inner(0);
+    let _tmp = 0;
+    while (true) {
+      const i = _tmp;
+      if (i < bytes.length) {
+        $bound_check(bytes, i);
+        const _p = bytes[i];
+        const _p$2 = 255;
+        moonbitlang$core$buffer$$Buffer$write_byte(inverted, (_p ^ _p$2) & 255);
+        _tmp = i + 1 | 0;
+        continue;
+      } else {
+        break;
+      }
+    }
+    moonbitlang$core$buffer$$Buffer$write_bytes(output, moonbitlang$core$buffer$$Buffer$contents(inverted));
+    return;
+  } else {
+    if (n$2 <= 8) {
+      const _p = 20;
+      const _p$2 = n$2 & 255;
+      moonbitlang$core$buffer$$Buffer$write_byte(output, (_p + _p$2 | 0) & 255);
+    } else {
+      moonbitlang$core$buffer$$Buffer$write_byte(output, 29);
+      if (n$2 > 255) {
+        moonbitlang$core$abort$$abort$3$("n is too large");
+      }
+      moonbitlang$core$buffer$$Buffer$write_byte(output, n$2 & 255);
+    }
+    moonbitlang$core$buffer$$Buffer$write_bytes(output, bytes);
+    return;
+  }
+}
+function zxch3n$flock$memcomparable$$KeyPart$encode_with_output(self, output) {
+  switch (self.$tag) {
+    case 0: {
+      const _Bytes = self;
+      const _bytes = _Bytes._0;
+      const _bind = _bytes;
+      zxch3n$flock$memcomparable$$encode_bytes(moonbitlang$core$bytes$$Bytes$sub$46$inner(_bind, 0, _bind.length), output);
+      return;
+    }
+    case 1: {
+      const _String = self;
+      const _s = _String._0;
+      zxch3n$flock$memcomparable$$encode_string(_s, output);
+      return;
+    }
+    case 2: {
+      const _Int = self;
+      const _n = _Int._0;
+      zxch3n$flock$memcomparable$$bigint_to_be_bytes(_n, output);
+      return;
+    }
+    case 3: {
+      const _Float = self;
+      const _f = _Float._0;
+      zxch3n$flock$memcomparable$$encode_float(_f, output);
+      return;
+    }
+    case 4: {
+      moonbitlang$core$buffer$$Buffer$write_byte(output, 38);
+      return;
+    }
+    default: {
+      moonbitlang$core$buffer$$Buffer$write_byte(output, 39);
+      return;
+    }
+  }
+}
+function zxch3n$flock$memcomparable$$Key$encode(self) {
+  const output = moonbitlang$core$buffer$$new$46$inner(0);
+  const _arr = self.parts;
+  const _len = _arr.length;
+  let _tmp = 0;
+  while (true) {
+    const _i = _tmp;
+    if (_i < _len) {
+      const part = _arr[_i];
+      zxch3n$flock$memcomparable$$KeyPart$encode_with_output(part, output);
+      _tmp = _i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  return moonbitlang$core$buffer$$Buffer$contents(output);
+}
+function zxch3n$flock$memcomparable$$parse_slice(bytes, start) {
+  const output = moonbitlang$core$buffer$$new$46$inner(0);
+  let i = start;
+  while (true) {
+    if (i < (bytes.end - bytes.start | 0)) {
+      const b = moonbitlang$core$bytes$$BytesView$at(bytes, i);
+      i = i + 1 | 0;
+      const _p = 0;
+      if (b === _p) {
+        let _tmp;
+        if (i < (bytes.end - bytes.start | 0)) {
+          const _p$2 = moonbitlang$core$bytes$$BytesView$at(bytes, i);
+          const _p$3 = 255;
+          _tmp = _p$2 === _p$3;
+        } else {
+          _tmp = false;
+        }
+        if (_tmp) {
+          moonbitlang$core$buffer$$Buffer$write_byte(output, 0);
+          i = i + 1 | 0;
+          continue;
+        } else {
+          const _bind = moonbitlang$core$buffer$$Buffer$contents(output);
+          return new Result$Ok$1$({ _0: moonbitlang$core$bytes$$Bytes$sub$46$inner(_bind, 0, _bind.length), _1: i });
+        }
+      }
+      moonbitlang$core$buffer$$Buffer$write_byte(output, b);
+      continue;
+    } else {
+      break;
+    }
+  }
+  return new Result$Err$1$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF);
+}
+function zxch3n$flock$memcomparable$$bytes_to_bigint(bytes) {
+  let n = moonbitlang$core$bigint$$BigInt$from_int64($0L);
+  let base = moonbitlang$core$bigint$$BigInt$from_int64($1L);
+  let _tmp = (bytes.end - bytes.start | 0) - 1 | 0;
+  while (true) {
+    const i = _tmp;
+    if (i >= 0) {
+      const byte_val = moonbitlang$core$bigint$$BigInt$from_int64(moonbitlang$core$int$$Int$to_int64(moonbitlang$core$bytes$$BytesView$at(bytes, i)));
+      n = moonbitlang$core$builtin$$Add$add$8$(n, moonbitlang$core$builtin$$Mul$mul$8$(base, byte_val));
+      base = moonbitlang$core$builtin$$Mul$mul$8$(base, moonbitlang$core$bigint$$BigInt$from_int64($256L));
+      _tmp = i - 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  return n;
+}
+function zxch3n$flock$memcomparable$$bigint_from_be_bytes_with_tag(bytes, tag) {
+  let _tmp;
+  if (20 <= tag) {
+    const _p = 20;
+    const _p$2 = 8 & 255;
+    _tmp = tag <= ((_p + _p$2 | 0) & 255);
+  } else {
+    _tmp = false;
+  }
+  if (_tmp) {
+    const _p = 20;
+    const n = (tag - _p | 0) & 255;
+    if ((bytes.end - bytes.start | 0) < n) {
+      return new Result$Err$2$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF);
+    }
+    const num_bytes = moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, 0, n);
+    const rest = moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, n, undefined);
+    return new Result$Ok$2$({ _0: rest, _1: zxch3n$flock$memcomparable$$bytes_to_bigint(num_bytes) });
+  } else {
+    let _tmp$2;
+    const _p = 20;
+    const _p$2 = 8 & 255;
+    if (((_p - _p$2 | 0) & 255) <= tag) {
+      _tmp$2 = tag < 20;
+    } else {
+      _tmp$2 = false;
+    }
+    if (_tmp$2) {
+      const _p$3 = 20;
+      const n = (_p$3 - tag | 0) & 255;
+      if ((bytes.end - bytes.start | 0) < n) {
+        return new Result$Err$2$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF);
+      }
+      const num_bytes = moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, 0, n);
+      const rest = moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, n, undefined);
+      const inverted = moonbitlang$core$buffer$$new$46$inner(0);
+      let _tmp$3 = 0;
+      while (true) {
+        const i = _tmp$3;
+        if (i < (num_bytes.end - num_bytes.start | 0)) {
+          const _p$4 = moonbitlang$core$bytes$$BytesView$at(num_bytes, i);
+          const _p$5 = 255;
+          moonbitlang$core$buffer$$Buffer$write_byte(inverted, (_p$4 ^ _p$5) & 255);
+          _tmp$3 = i + 1 | 0;
+          continue;
+        } else {
+          break;
+        }
+      }
+      const _bind = moonbitlang$core$buffer$$Buffer$contents(inverted);
+      return new Result$Ok$2$({ _0: rest, _1: moonbitlang$core$builtin$$Neg$neg$8$(zxch3n$flock$memcomparable$$bytes_to_bigint(moonbitlang$core$bytes$$Bytes$sub$46$inner(_bind, 0, _bind.length))) });
+    } else {
+      const _p$3 = 11;
+      if (tag === _p$3) {
+        if ((bytes.end - bytes.start | 0) < 1) {
+          return new Result$Err$2$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF);
+        }
+        const raw_length = moonbitlang$core$bytes$$BytesView$at(bytes, 0);
+        const _p$4 = 255;
+        const n = (raw_length ^ _p$4) & 255;
+        if ((bytes.end - bytes.start | 0) < (n + 1 | 0)) {
+          return new Result$Err$2$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF);
+        }
+        const num_bytes = moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, 1, n + 1 | 0);
+        const rest = moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, n + 1 | 0, undefined);
+        const inverted = moonbitlang$core$buffer$$new$46$inner(0);
+        let _tmp$3 = 0;
+        while (true) {
+          const i = _tmp$3;
+          if (i < (num_bytes.end - num_bytes.start | 0)) {
+            const _p$5 = moonbitlang$core$bytes$$BytesView$at(num_bytes, i);
+            const _p$6 = 255;
+            moonbitlang$core$buffer$$Buffer$write_byte(inverted, (_p$5 ^ _p$6) & 255);
+            _tmp$3 = i + 1 | 0;
+            continue;
+          } else {
+            break;
+          }
+        }
+        const _bind = moonbitlang$core$buffer$$Buffer$contents(inverted);
+        return new Result$Ok$2$({ _0: rest, _1: moonbitlang$core$builtin$$Neg$neg$8$(zxch3n$flock$memcomparable$$bytes_to_bigint(moonbitlang$core$bytes$$Bytes$sub$46$inner(_bind, 0, _bind.length))) });
+      } else {
+        const _p$4 = 29;
+        if (tag === _p$4) {
+          if ((bytes.end - bytes.start | 0) < 1) {
+            return new Result$Err$2$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF);
+          }
+          const raw_length = moonbitlang$core$bytes$$BytesView$at(bytes, 0);
+          const n = raw_length;
+          if ((bytes.end - bytes.start | 0) < (n + 1 | 0)) {
+            return new Result$Err$2$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF);
+          }
+          const num_bytes = moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, 1, n + 1 | 0);
+          const rest = moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, n + 1 | 0, undefined);
+          return new Result$Ok$2$({ _0: rest, _1: zxch3n$flock$memcomparable$$bytes_to_bigint(num_bytes) });
+        } else {
+          return new Result$Err$2$(new Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$InvalidTag(tag));
+        }
+      }
+    }
+  }
+}
+function zxch3n$flock$memcomparable$$decode_float(bytes, start) {
+  if ((start + 8 | 0) > (bytes.end - bytes.start | 0)) {
+    return new Result$Err$3$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$UnexpectedEOF);
+  }
+  const data = moonbitlang$core$array$$Array$new$46$inner$2$(0);
+  let _tmp = 0;
+  while (true) {
+    const i = _tmp;
+    if (i < 8) {
+      moonbitlang$core$array$$Array$push$2$(data, moonbitlang$core$bytes$$BytesView$at(bytes, start + i | 0));
+      _tmp = i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  const bits = zxch3n$flock$memcomparable$$uint64_from_be_bytes(moonbitlang$core$bytes$$Bytes$from_array({ buf: data, start: 0, end: data.length }));
+  const f = moonbitlang$core$builtin$$Eq$equal$18$(moonbitlang$core$builtin$$BitAnd$land$18$(bits, $_9223372036854775808L), $0L) ? zxch3n$flock$memcomparable$$double_from_bits(moonbitlang$core$builtin$$BitXOr$lxor$18$(bits, $_1L)) : zxch3n$flock$memcomparable$$double_from_bits(moonbitlang$core$builtin$$BitXOr$lxor$18$(bits, $_9223372036854775808L));
+  return new Result$Ok$3$({ _0: f, _1: start + 8 | 0 });
+}
+function zxch3n$flock$memcomparable$$Key$decode(bytes) {
+  const key = zxch3n$flock$memcomparable$$Key$new();
+  let i = 0;
+  while (true) {
+    if (i < (bytes.end - bytes.start | 0)) {
+      const tag = moonbitlang$core$bytes$$BytesView$at(bytes, i);
+      i = i + 1 | 0;
+      if (tag === 2) {
+        const _bind = zxch3n$flock$memcomparable$$parse_slice(bytes, i);
+        let _bind$2;
+        if (_bind.$tag === 1) {
+          const _ok = _bind;
+          _bind$2 = _ok._0;
+        } else {
+          return _bind;
+        }
+        const _data = _bind$2._0;
+        const _next_i = _bind$2._1;
+        const _bind$3 = zxch3n$flock$types$$Utf8Str$from_bytes_view(_data);
+        if (_bind$3 === undefined) {
+          return new Result$Err$4$(Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$InvalidUTF8);
+        } else {
+          const _Some = _bind$3;
+          const _s = _Some;
+          zxch3n$flock$memcomparable$$Key$push(key, new KeyPart$String(_s));
+        }
+        i = _next_i;
+      } else {
+        if (tag === 1) {
+          const _bind = zxch3n$flock$memcomparable$$parse_slice(bytes, i);
+          let _bind$2;
+          if (_bind.$tag === 1) {
+            const _ok = _bind;
+            _bind$2 = _ok._0;
+          } else {
+            return _bind;
+          }
+          const _data = _bind$2._0;
+          const _next_i = _bind$2._1;
+          zxch3n$flock$memcomparable$$Key$push(key, new KeyPart$Bytes(moonbitlang$core$bytes$$Bytes$from_iter(moonbitlang$core$bytes$$BytesView$iter(_data))));
+          i = _next_i;
+        } else {
+          if (tag >= 11 && tag <= 29) {
+            const _bind = zxch3n$flock$memcomparable$$bigint_from_be_bytes_with_tag(moonbitlang$core$bytes$$BytesView$sub$46$inner(bytes, i, undefined), tag);
+            let _bind$2;
+            if (_bind.$tag === 1) {
+              const _ok = _bind;
+              _bind$2 = _ok._0;
+            } else {
+              return _bind;
+            }
+            const _view = _bind$2._0;
+            const _data = _bind$2._1;
+            zxch3n$flock$memcomparable$$Key$push(key, new KeyPart$Int(_data));
+            i = (bytes.end - bytes.start | 0) - (_view.end - _view.start | 0) | 0;
+          } else {
+            if (tag === 33) {
+              const _bind = zxch3n$flock$memcomparable$$decode_float(bytes, i);
+              let _bind$2;
+              if (_bind.$tag === 1) {
+                const _ok = _bind;
+                _bind$2 = _ok._0;
+              } else {
+                return _bind;
+              }
+              const _data = _bind$2._0;
+              const _next_i = _bind$2._1;
+              zxch3n$flock$memcomparable$$Key$push(key, new KeyPart$Float(_data));
+              i = _next_i;
+            } else {
+              if (tag === 38) {
+                zxch3n$flock$memcomparable$$Key$push(key, KeyPart$False);
+              } else {
+                if (tag === 39) {
+                  zxch3n$flock$memcomparable$$Key$push(key, KeyPart$True);
+                } else {
+                  return new Result$Err$4$(new Error$zxch3n$47$flock$47$memcomparable$46$KeyError$46$InvalidTag(tag));
+                }
+              }
+            }
+          }
+        }
+      }
+      continue;
+    } else {
+      break;
+    }
+  }
+  return new Result$Ok$4$(key);
+}
+function zxch3n$flock$memcomparable$$key_part_to_js_part(part) {
+  switch (part.$tag) {
+    case 0: {
+      const _Bytes = part;
+      const _bytes = _Bytes._0;
+      return new KeyJsPart$Bytes(_bytes);
+    }
+    case 1: {
+      const _String = part;
+      const _s = _String._0;
+      return new KeyJsPart$String(zxch3n$flock$types$$Utf8Str$to_string(_s));
+    }
+    case 2: {
+      const _Int = part;
+      const _n = _Int._0;
+      return new KeyJsPart$Number(moonbitlang$core$int64$$Int64$to_double(moonbitlang$core$bigint$$BigInt$to_int64(_n)));
+    }
+    case 3: {
+      const _Float = part;
+      const _f = _Float._0;
+      return new KeyJsPart$Number(_f);
+    }
+    case 4: {
+      return KeyJsPart$False;
+    }
+    default: {
+      return KeyJsPart$True;
+    }
+  }
+}
+function zxch3n$flock$memcomparable$$js_part_to_key_part(part) {
+  switch (part.$tag) {
+    case 2: {
+      const _Bytes = part;
+      const _bytes = _Bytes._0;
+      return new KeyPart$Bytes(_bytes);
+    }
+    case 1: {
+      const _String = part;
+      const _s = _String._0;
+      return new KeyPart$String(zxch3n$flock$types$$Utf8Str$from_string(_s));
+    }
+    case 0: {
+      const _Number = part;
+      const _n = _Number._0;
+      return moonbitlang$core$int64$$Int64$to_double(moonbitlang$core$double$$Double$to_int64(_n)) === _n ? new KeyPart$Int(moonbitlang$core$bigint$$BigInt$from_int64(moonbitlang$core$double$$Double$to_int64(_n))) : new KeyPart$Float(_n);
+    }
+    case 3: {
+      return KeyPart$True;
+    }
+    default: {
+      return KeyPart$False;
+    }
+  }
+}
+function zxch3n$flock$memcomparable$$encode_key(parts) {
+  const key = zxch3n$flock$memcomparable$$Key$new();
+  const _len = parts.length;
+  let _tmp = 0;
+  while (true) {
+    const _i = _tmp;
+    if (_i < _len) {
+      const part = parts[_i];
+      moonbitlang$core$array$$Array$push$15$(key.parts, zxch3n$flock$memcomparable$$js_part_to_key_part(part));
+      _tmp = _i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  return zxch3n$flock$memcomparable$$Key$encode(key);
+}
+function zxch3n$flock$memcomparable$$decode_key(bytes) {
+  let key;
+  let _try_err;
+  _L: {
+    _L$2: {
+      const _bind = zxch3n$flock$memcomparable$$Key$decode(moonbitlang$core$bytes$$Bytes$sub$46$inner(bytes, 0, bytes.length));
+      if (_bind.$tag === 1) {
+        const _ok = _bind;
+        key = _ok._0;
+      } else {
+        const _err = _bind;
+        const _tmp = _err._0;
+        _try_err = _tmp;
+        break _L$2;
+      }
+      break _L;
+    }
+    key = moonbitlang$core$abort$$abort$0$("Failed to decode key");
+  }
+  const parts = moonbitlang$core$array$$Array$new$46$inner$14$(0);
+  const _arr = key.parts;
+  const _len = _arr.length;
+  let _tmp = 0;
+  while (true) {
+    const _i = _tmp;
+    if (_i < _len) {
+      const part = _arr[_i];
+      moonbitlang$core$array$$Array$push$14$(parts, zxch3n$flock$memcomparable$$key_part_to_js_part(part));
+      _tmp = _i + 1 | 0;
+      continue;
+    } else {
+      break;
+    }
+  }
+  return parts;
+}
+export { zxch3n$flock$memcomparable$$encode_key as encode_key, zxch3n$flock$memcomparable$$decode_key as decode_key }