{"version":3,"sources":["~lib/rt/common.ts","~lib/shared/typeinfo.ts","~lib/rt/pure.ts","~lib/rt/tlsf.ts","~lib/gc.ts","assembly/AbstractHistogramBase.ts","assembly/ulp.ts","~lib/util/math.ts","~lib/math.ts","assembly/formatters.ts","~lib/util/number.ts","~lib/util/string.ts","~lib/string.ts","~lib/memory.ts","~lib/util/memory.ts","~lib/util/error.ts","~lib/number.ts","~lib/builtins.ts","assembly/encoding.ts","assembly/packedarray/bitcount.ts","assembly/packedarray/PackedArrayContext.ts","assembly/packedarray/PackedArray.ts","assembly/index.ts","assembly/Histogram.ts","~lib/arraybuffer.ts","~lib/typedarray.ts","assembly/PercentileIterator.ts","assembly/HistogramIterationValue.ts","assembly/RecordedValuesIterator.ts","assembly/ByteBuffer.ts","assembly/ZigZagEncoding.ts","~lib/rt.ts","~lib/array.ts"],"names":[],"mappings":"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","sourceRoot":"./untouched.wasm","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n\n// ╒════════════════ Common block layout (32-bit) ═════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │                           MM info                             │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │                           GC info                             │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │                          runtime id                           │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │                         runtime size                          │ -4\n// ╞═══════════════════════════════════════════════════════════════╡\n// │                              ...                              │ ref\n@unmanaged export class BLOCK {\n  /** Memory manager info. */\n  mmInfo: usize; // WASM64 needs adaption\n  /** Garbage collector info. */\n  gcInfo: u32;\n  /** Runtime class id. */\n  rtId: u32;\n  /** Runtime object size. */\n  rtSize: u32;\n}\n\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = (offsetof<BLOCK>() + AL_MASK) & ~AL_MASK;\n\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │                             count                             │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │                      Typeinfo#flags [id=0]                    │ id < count\n// ├ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┤\n// │                      Typeinfo#base  [id=0]                    │\n// ├───────────────────────────────────────────────────────────────┤\n// │                              ...                              │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n  /** Flags describing the shape of this class type. */\n  flags: TypeinfoFlags = TypeinfoFlags.NONE;\n  /** Base class id or `0` if none. */\n  base: u32 = 0;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n  /** No specific flags. */\n  NONE = 0,\n  /** Type is an `ArrayBufferView`. */\n  ARRAYBUFFERVIEW = 1 << 0,\n  /** Type is an `Array`. */\n  ARRAY = 1 << 1,\n  /** Type is a `StaticArray`. */\n  STATICARRAY = 1 << 2,\n  /** Type is a `Set`. */\n  SET = 1 << 3,\n  /** Type is a `Map`. */\n  MAP = 1 << 4,\n  /** Type is inherently acyclic. */\n  ACYCLIC = 1 << 5,\n  /** Value alignment of 1 byte. */\n  VALUE_ALIGN_0 = 1 << 6,\n  /** Value alignment of 2 bytes. */\n  VALUE_ALIGN_1 = 1 << 7,\n  /** Value alignment of 4 bytes. */\n  VALUE_ALIGN_2 = 1 << 8,\n  /** Value alignment of 8 bytes. */\n  VALUE_ALIGN_3 = 1 << 9,\n  /** Value alignment of 16 bytes. */\n  VALUE_ALIGN_4 = 1 << 10,\n  /** Value is a signed type. */\n  VALUE_SIGNED = 1 << 11,\n  /** Value is a float type. */\n  VALUE_FLOAT = 1 << 12,\n  /** Value type is nullable. */\n  VALUE_NULLABLE = 1 << 13,\n  /** Value type is managed. */\n  VALUE_MANAGED = 1 << 14,\n  /** Key alignment of 1 byte. */\n  KEY_ALIGN_0 = 1 << 15,\n  /** Key alignment of 2 bytes. */\n  KEY_ALIGN_1 = 1 << 16,\n  /** Key alignment of 4 bytes. */\n  KEY_ALIGN_2 = 1 << 17,\n  /** Key alignment of 8 bytes. */\n  KEY_ALIGN_3 = 1 << 18,\n  /** Key alignment of 16 bytes. */\n  KEY_ALIGN_4 = 1 << 19,\n  /** Key is a signed type. */\n  KEY_SIGNED = 1 << 20,\n  /** Key is a float type. */\n  KEY_FLOAT = 1 << 21,\n  /** Key type is nullable. */\n  KEY_NULLABLE = 1 << 22,\n  /** Key type is managed. */\n  KEY_MANAGED = 1 << 23\n}\n","import { DEBUG, BLOCK_OVERHEAD } from \"rt/common\";\nimport { Block, freeBlock, ROOT } from \"rt/tlsf\";\nimport { TypeinfoFlags } from \"shared/typeinfo\";\nimport { onincrement, ondecrement, onfree, onalloc } from \"./rtrace\";\n\n// === A Pure Reference Counting Garbage Collector ===\n// see: https://researcher.watson.ibm.com/researcher/files/us-bacon/Bacon03Pure.pdf\n\n// ╒══════════════════════ GC Info structure ══════════════════════╕\n// │  3                   2                   1                    │\n// │1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0│\n// ├─┼─┴─┴─┼─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │B│color│                     refCount                          │\n// └─┴─────┴───────────────────────────────────────────────────────┘\n// B: buffered\n\n// @ts-ignore: decorator\n@inline const BUFFERED_MASK: u32 = 1 << ((sizeof<u32>() * 8) - 1);\n// @ts-ignore: decorator\n@inline const COLOR_BITS = 3;\n// @ts-ignore: decorator\n@inline const COLOR_SHIFT: u32 = ctz(BUFFERED_MASK) - COLOR_BITS;\n// @ts-ignore: decorator\n@inline const COLOR_MASK: u32 = ((1 << COLOR_BITS) - 1) << COLOR_SHIFT;\n// @ts-ignore: decorator\n@inline export const REFCOUNT_MASK: u32 = (1 << COLOR_SHIFT) - 1;\n\n// ╒════════╤═══════════════════ Colors ═══════════════════════════╕\n// │ Color  │ Meaning                                              │\n// ├────────┼──────────────────────────────────────────────────────┤\n// │ BLACK  │ In use or free                                       │\n// │ GRAY   │ Possible member of cycle                             │\n// │ WHITE  │ Member of garbage cycle                              │\n// │ PURPLE │ Possible root of cycle                               │\n// │ RED    │ Candidate cycle undergoing Σ-computation *concurrent │\n// │ ORANGE │ Candidate cycle awaiting epoch boundary  *concurrent │\n// └────────┴──────────────────────────────────────────────────────┘\n// Acyclic detection has been decoupled, hence no GREEN.\n\n// @ts-ignore: decorator\n@inline const COLOR_BLACK: u32 = 0 << COLOR_SHIFT;\n// @ts-ignore: decorator\n@inline const COLOR_GRAY: u32 = 1 << COLOR_SHIFT;\n// @ts-ignore: decorator\n@inline const COLOR_WHITE: u32 = 2 << COLOR_SHIFT;\n// @ts-ignore: decorator\n@inline const COLOR_PURPLE: u32 = 3 << COLOR_SHIFT;\n// @ts-ignore: decorator\n// @inline const COLOR_RED: u32 = 4 << COLOR_SHIFT;\n// @ts-ignore: decorator\n// @inline const COLOR_ORANGE: u32 = 5 << COLOR_SHIFT;\n\n// @ts-ignore: decorator\n@inline const VISIT_DECREMENT = 1; // guard 0\n// @ts-ignore: decorator\n@inline const VISIT_MARKGRAY = 2;\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 3;\n// @ts-ignore: decorator\n@inline const VISIT_SCANBLACK = 4;\n// @ts-ignore: decorator\n@inline const VISIT_COLLECTWHITE = 5;\n\n// @ts-ignore: decorator\n@global @unsafe @lazy\nfunction __visit(ref: usize, cookie: i32): void { // eslint-disable-line @typescript-eslint/no-unused-vars\n  if (ref < __heap_base) return;\n  if (isDefined(__GC_ALL_ACYCLIC)) {\n    if (DEBUG) assert(cookie == VISIT_DECREMENT);\n    decrement(changetype<Block>(ref - BLOCK_OVERHEAD));\n  } else {\n    let s = changetype<Block>(ref - BLOCK_OVERHEAD);\n    switch (cookie) {\n      case VISIT_DECREMENT: {\n        decrement(s);\n        break;\n      }\n      case VISIT_MARKGRAY: {\n        if (DEBUG) assert((s.gcInfo & REFCOUNT_MASK) > 0);\n        s.gcInfo = s.gcInfo - 1;\n        markGray(s);\n        break;\n      }\n      case VISIT_SCAN: {\n        scan(s);\n        break;\n      }\n      case VISIT_SCANBLACK: {\n        let info = s.gcInfo;\n        assert((info & ~REFCOUNT_MASK) == ((info + 1) & ~REFCOUNT_MASK)); // overflow\n        s.gcInfo = info + 1;\n        if ((info & COLOR_MASK) != COLOR_BLACK) {\n          scanBlack(s);\n        }\n        break;\n      }\n      case VISIT_COLLECTWHITE: {\n        collectWhite(s);\n        break;\n      }\n      default: if (DEBUG) assert(false);\n    }\n  }\n}\n\n/** Increments the reference count of the specified block by one.*/\nfunction increment(s: Block): void {\n  var info = s.gcInfo;\n  assert((info & ~REFCOUNT_MASK) == ((info + 1) & ~REFCOUNT_MASK)); // overflow\n  s.gcInfo = info + 1;\n  if (isDefined(ASC_RTRACE)) onincrement(s);\n  if (DEBUG) assert(!(s.mmInfo & 1)); // used\n}\n\n/** Decrements the reference count of the specified block by one, possibly freeing it. */\n// @ts-ignore: decorator\n@lazy\nfunction decrement(s: Block): void {\n  var info = s.gcInfo;\n  var rc = info & REFCOUNT_MASK;\n  if (isDefined(ASC_RTRACE)) ondecrement(s);\n  if (DEBUG) assert(!(s.mmInfo & 1)); // used\n  if (rc == 1) {\n    __visit_members(changetype<usize>(s) + BLOCK_OVERHEAD, VISIT_DECREMENT);\n    if (isDefined(__GC_ALL_ACYCLIC)) {\n      if (DEBUG) assert(!(info & BUFFERED_MASK));\n      finalize(s);\n    } else {\n      if (!(info & BUFFERED_MASK)) {\n        finalize(s);\n      } else {\n        s.gcInfo = BUFFERED_MASK | COLOR_BLACK | 0;\n      }\n    }\n  } else {\n    if (DEBUG) assert(rc > 0);\n    if (isDefined(__GC_ALL_ACYCLIC)) {\n      s.gcInfo = (info & ~REFCOUNT_MASK) | (rc - 1);\n    } else {\n      if (!(__typeinfo(s.rtId) & TypeinfoFlags.ACYCLIC)) {\n        s.gcInfo = BUFFERED_MASK | COLOR_PURPLE | (rc - 1);\n        if (!(info & BUFFERED_MASK)) {\n          appendRoot(s);\n        }\n      } else {\n        s.gcInfo = (info & ~REFCOUNT_MASK) | (rc - 1);\n      }\n    }\n  }\n}\n\n/** Finalizes the specified block, giving it back to the memory manager. */\nfunction finalize(s: Block): void {\n  if (isDefined(__finalize)) {\n    __finalize(changetype<usize>(s) + BLOCK_OVERHEAD);\n  }\n  freeBlock(ROOT, s);\n}\n\n/** Buffer of possible roots. */\n// @ts-ignore: decorator\n@lazy var ROOTS: usize;\n/** Current absolute offset into the `ROOTS` buffer. */\n// @ts-ignore: decorator\n@lazy var CUR: usize = 0;\n/** Current absolute end offset into the `ROOTS` buffer. */\n// @ts-ignore: decorator\n@lazy var END: usize = 0;\n\n/** Appends a block to possible roots. */\nfunction appendRoot(s: Block): void {\n  var cur = CUR;\n  if (cur >= END) {\n    growRoots(); // TBD: either that or pick a default and force collection on overflow\n    cur = CUR;\n  }\n  store<Block>(cur, s);\n  CUR = cur + sizeof<usize>();\n}\n\n/** Grows the roots buffer if it ran full. */\nfunction growRoots(): void {\n  var oldRoots = ROOTS;\n  var oldSize = CUR - oldRoots;\n  var newSize = max(oldSize * 2, 64 << alignof<usize>());\n  var newRoots = __alloc(newSize, 0);\n  if (isDefined(ASC_RTRACE)) onfree(changetype<Block>(newRoots - BLOCK_OVERHEAD)); // neglect unmanaged\n  memory.copy(newRoots, oldRoots, oldSize);\n  if (oldRoots) {\n    if (isDefined(ASC_RTRACE)) onalloc(changetype<Block>(oldRoots - BLOCK_OVERHEAD)); // neglect unmanaged\n    __free(oldRoots);\n  }\n  ROOTS = newRoots;\n  CUR = newRoots + oldSize;\n  END = newRoots + newSize;\n}\n\n/** Collects cyclic garbage. */\n// @ts-ignore: decorator\n@global @unsafe @lazy\nexport function __collect(): void {\n  if (isDefined(__GC_ALL_ACYCLIC)) return;\n\n  // markRoots\n  var roots = ROOTS;\n  var cur = roots;\n  for (let pos = cur, end = CUR; pos < end; pos += sizeof<usize>()) {\n    let s = load<Block>(pos);\n    let info = s.gcInfo;\n    if ((info & COLOR_MASK) == COLOR_PURPLE && (info & REFCOUNT_MASK) > 0) {\n      markGray(s);\n      store<Block>(cur, s);\n      cur += sizeof<usize>();\n    } else {\n      if ((info & COLOR_MASK) == COLOR_BLACK && !(info & REFCOUNT_MASK)) {\n        finalize(s);\n      } else {\n        s.gcInfo = info & ~BUFFERED_MASK;\n      }\n    }\n  }\n  CUR = cur;\n\n  // scanRoots\n  for (let pos = roots; pos < cur; pos += sizeof<usize>()) {\n    scan(load<Block>(pos));\n  }\n\n  // collectRoots\n  for (let pos = roots; pos < cur; pos += sizeof<usize>()) {\n    let s = load<Block>(pos);\n    s.gcInfo = s.gcInfo & ~BUFFERED_MASK;\n    collectWhite(s);\n  }\n  CUR = roots;\n}\n\n/** Marks a block as gray (possible member of cycle) during the collection phase. */\nfunction markGray(s: Block): void {\n  var info = s.gcInfo;\n  if ((info & COLOR_MASK) != COLOR_GRAY) {\n    s.gcInfo = (info & ~COLOR_MASK) | COLOR_GRAY;\n    __visit_members(changetype<usize>(s) + BLOCK_OVERHEAD, VISIT_MARKGRAY);\n  }\n}\n\n/** Scans a block during the collection phase, determining whether it is garbage or not. */\nfunction scan(s: Block): void {\n  var info = s.gcInfo;\n  if ((info & COLOR_MASK) == COLOR_GRAY) {\n    if ((info & REFCOUNT_MASK) > 0) {\n      scanBlack(s);\n    } else {\n      s.gcInfo = (info & ~COLOR_MASK) | COLOR_WHITE;\n      __visit_members(changetype<usize>(s) + BLOCK_OVERHEAD, VISIT_SCAN);\n    }\n  }\n}\n\n/** Marks a block as black (in use) if it was found to be reachable during the collection phase. */\nfunction scanBlack(s: Block): void {\n  s.gcInfo = (s.gcInfo & ~COLOR_MASK) | COLOR_BLACK;\n  __visit_members(changetype<usize>(s) + BLOCK_OVERHEAD, VISIT_SCANBLACK);\n}\n\n/** Collects all white (member of a garbage cycle) nodes when completing the collection phase.  */\nfunction collectWhite(s: Block): void {\n  var info = s.gcInfo;\n  if ((info & COLOR_MASK) == COLOR_WHITE && !(info & BUFFERED_MASK)) {\n    s.gcInfo = (info & ~COLOR_MASK) | COLOR_BLACK;\n    __visit_members(changetype<usize>(s) + BLOCK_OVERHEAD, VISIT_COLLECTWHITE);\n    finalize(s);\n  }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __retain(ptr: usize): usize {\n  if (ptr > __heap_base) increment(changetype<Block>(ptr - BLOCK_OVERHEAD));\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __release(ptr: usize): void {\n  if (ptr > __heap_base) decrement(changetype<Block>(ptr - BLOCK_OVERHEAD));\n}\n","import { AL_BITS, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"rt/common\";\nimport { onfree, onalloc, onrealloc } from \"./rtrace\";\nimport { REFCOUNT_MASK } from \"./pure\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ |                    FL                       │ SB = SL + AL  │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB)  [12]: < 1M\n// [01]: < 512B       [13]: < 2M\n// [02]: < 1K         [14]: < 4M\n// [03]: < 2K         [15]: < 8M\n// [04]: < 4K         [16]: < 16M\n// [05]: < 8K         [17]: < 32M\n// [06]: < 16K        [18]: < 64M\n// [07]: < 32K        [19]: < 128M\n// [08]: < 64K        [20]: < 256M\n// [09]: < 128K       [21]: < 512M\n// [10]: < 256K       [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┼─┤ overhead   ┐\n// │                          size                           │0│L│F│ ◄─┐ info\n// ├─────────────────────────────────────────────────────────┴─┴─┴─┤   │\n// │                                                               │   │\n// │               ... additional runtime overhead ...             │   │\n// │                                                               │   │\n// ╞═══════════════════════════════════════════════════════════════╡   │      ┐ ┘\n// │                        if free: ◄ prev                        │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤   │\n// │                        if free: next ►                        │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤   │\n// │                             ...                               │   │    = 0\n// ├───────────────────────────────────────────────────────────────┤   │\n// │                        if free: back ▲                        │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ payload  ┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n  /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n  prev: Block | null;\n  /** Next free block, if any. Only valid if free, otherwise part of payload. */\n  next: Block | null;\n\n  // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = (3 * sizeof<usize>() + AL_MASK) & ~AL_MASK; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n  return load<Block>(changetype<usize>(block) - sizeof<usize>());\n}\n\n/** Gets the right block of of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n  return changetype<Block>(changetype<usize>(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤          ┐\n// │        0        |           flMap                            S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡      │\n// │                           slMap[0] S                          │ ◄─┐  │\n// ├───────────────────────────────────────────────────────────────┤   │  │\n// │                           slMap[1]                            │ ◄─┤  │\n// ├───────────────────────────────────────────────────────────────┤  u32 │\n// │                           slMap[22]                           │ ◄─┘  │\n// ╞═══════════════════════════════════════════════════════════════╡    usize\n// │                            head[0]                            │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤      │\n// │                              ...                              │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤      │\n// │                           head[367]                           │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡      │\n// │                             tail                              │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘   SIZE   ┘\n// S: Small blocks map\n@unmanaged class Root {\n  /** First level bitmap. */\n  flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof<usize>();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof<u32>());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof<usize>();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof<usize>();\n\n// @ts-ignore: decorator\n@lazy export var ROOT: Root;\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n  return load<u32>(\n    changetype<usize>(root) + (fl << alignof<u32>()),\n    SL_START\n  );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n  store<u32>(\n    changetype<usize>(root) + (fl << alignof<u32>()),\n    slMap,\n    SL_START\n  );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n  return load<Block>(\n    changetype<usize>(root) + (((fl << SL_BITS) + <usize>sl) << alignof<usize>()),\n    HL_START\n  );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n  store<Block | null>(\n    changetype<usize>(root) + (((fl << SL_BITS) + <usize>sl) << alignof<usize>()),\n    head,\n    HL_START\n  );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n  return load<Block>(\n    changetype<usize>(root),\n    HL_END\n  );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n  store<Block>(\n    changetype<usize>(root),\n    tail,\n    HL_END\n  );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n  if (DEBUG) assert(block); // cannot be null\n  var blockInfo = block.mmInfo;\n  if (DEBUG) assert(blockInfo & FREE); // must be free\n\n  var right = GETRIGHT(block);\n  var rightInfo = right.mmInfo;\n\n  // merge with right block if also free\n  if (rightInfo & FREE) {\n    let newSize = (blockInfo & ~TAGS_MASK) + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n    if (newSize < BLOCK_MAXSIZE) {\n      removeBlock(root, right);\n      block.mmInfo = blockInfo = (blockInfo & TAGS_MASK) | newSize;\n      right = GETRIGHT(block);\n      rightInfo = right.mmInfo;\n      // 'back' is set below\n    }\n  }\n\n  // merge with left block if also free\n  if (blockInfo & LEFTFREE) {\n    let left = GETFREELEFT(block);\n    let leftInfo = left.mmInfo;\n    if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n    let newSize = (leftInfo & ~TAGS_MASK) + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK);\n    if (newSize < BLOCK_MAXSIZE) {\n      removeBlock(root, left);\n      left.mmInfo = blockInfo = (leftInfo & TAGS_MASK) | newSize;\n      block = left;\n      // 'back' is set below\n    }\n  }\n\n  right.mmInfo = rightInfo | LEFTFREE;\n  // right is no longer used now, hence rightInfo is not synced\n\n  // we now know the size of the block\n  var size = blockInfo & ~TAGS_MASK;\n  if (DEBUG) assert(size >= BLOCK_MINSIZE && size < BLOCK_MAXSIZE); // must be a valid size\n  if (DEBUG) assert(changetype<usize>(block) + BLOCK_OVERHEAD + size == changetype<usize>(right)); // must match\n\n  // set 'back' to itself at the end of block\n  store<Block>(changetype<usize>(right) - sizeof<usize>(), block);\n\n  // mapping_insert\n  var fl: usize, sl: u32;\n  if (size < SB_SIZE) {\n    fl = 0;\n    sl = <u32>(size >> AL_BITS);\n  } else {\n    const inv: usize = sizeof<usize>() * 8 - 1;\n    fl = inv - clz<usize>(size);\n    sl = <u32>((size >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n    fl -= SB_BITS - 1;\n  }\n  if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n  // perform insertion\n  var head = GETHEAD(root, fl, sl);\n  block.prev = null;\n  block.next = head;\n  if (head) head.prev = block;\n  SETHEAD(root, fl, sl, block);\n\n  // update first and second level maps\n  root.flMap |= (1 << fl);\n  SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n  var blockInfo = block.mmInfo;\n  if (DEBUG) assert(blockInfo & FREE); // must be free\n  var size = blockInfo & ~TAGS_MASK;\n  if (DEBUG) assert(size >= BLOCK_MINSIZE && size < BLOCK_MAXSIZE); // must be valid\n\n  // mapping_insert\n  var fl: usize, sl: u32;\n  if (size < SB_SIZE) {\n    fl = 0;\n    sl = <u32>(size >> AL_BITS);\n  } else {\n    const inv: usize = sizeof<usize>() * 8 - 1;\n    fl = inv - clz<usize>(size);\n    sl = <u32>((size >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n    fl -= SB_BITS - 1;\n  }\n  if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n  // link previous and next free block\n  var prev = block.prev;\n  var next = block.next;\n  if (prev) prev.next = next;\n  if (next) next.prev = prev;\n\n  // update head if we are removing it\n  if (block == GETHEAD(root, fl, sl)) {\n    SETHEAD(root, fl, sl, next);\n\n    // clear second level map if head is empty now\n    if (!next) {\n      let slMap = GETSL(root, fl);\n      SETSL(root, fl, slMap &= ~(1 << sl));\n\n      // clear first level map if second level is empty now\n      if (!slMap) root.flMap &= ~(1 << fl);\n    }\n  }\n  // note: does not alter left/back because it is likely that splitting\n  // is performed afterwards, invalidating those changes. so, the caller\n  // must perform those updates.\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n  // size was already asserted by caller\n\n  // mapping_search\n  var fl: usize, sl: u32;\n  if (size < SB_SIZE) {\n    fl = 0;\n    sl = <u32>(size >> AL_BITS);\n  } else {\n    const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n    const inv: usize = sizeof<usize>() * 8 - 1;\n    const invRound = inv - SL_BITS;\n    let requestSize = size < halfMaxSize\n      ? size + (1 << (invRound - clz<usize>(size))) - 1\n      : size;\n    fl = inv - clz<usize>(requestSize);\n    sl = <u32>((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n    fl -= SB_BITS - 1;\n  }\n  if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n  // search second level\n  var slMap = GETSL(root, fl) & (~0 << sl);\n  var head: Block | null = null;\n  if (!slMap) {\n    // search next larger first level\n    let flMap = root.flMap & (~0 << (fl + 1));\n    if (!flMap) {\n      head = null;\n    } else {\n      fl = ctz<usize>(flMap);\n      slMap = GETSL(root, fl);\n      if (DEBUG) assert(slMap);  // can't be zero if fl points here\n      head = GETHEAD(root, fl, ctz<u32>(slMap));\n    }\n  } else {\n    head = GETHEAD(root, fl, ctz<u32>(slMap));\n  }\n  return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n  // size was already asserted by caller\n\n  var blockInfo = block.mmInfo;\n  if (DEBUG) assert(!(size & AL_MASK)); // size must be aligned so the new block is\n\n  // split if the block can hold another MINSIZE block incl. overhead\n  var remaining = (blockInfo & ~TAGS_MASK) - size;\n  if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n    block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n    let spare = changetype<Block>(changetype<usize>(block) + BLOCK_OVERHEAD + size);\n    spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n    insertBlock(root, spare); // also sets 'back'\n\n  // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n  } else {\n    block.mmInfo = blockInfo & ~FREE;\n    GETRIGHT(block).mmInfo &= ~LEFTFREE;\n  }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, end: usize): bool {\n  if (DEBUG) {\n    assert(\n      start <= end &&       // must be valid\n      !(start & AL_MASK) && // must be aligned\n      !(end & AL_MASK)      // must be aligned\n    );\n  }\n\n  var tail = GETTAIL(root);\n  var tailInfo: usize = 0;\n  if (tail) { // more memory\n    if (DEBUG) assert(start >= changetype<usize>(tail) + BLOCK_OVERHEAD);\n\n    // merge with current tail if adjacent\n    if (start - BLOCK_OVERHEAD == changetype<usize>(tail)) {\n      start -= BLOCK_OVERHEAD;\n      tailInfo = tail.mmInfo;\n    } else {\n      // We don't do this, but a user might `memory.grow` manually\n      // leading to non-adjacent pages managed by TLSF.\n    }\n\n  } else if (DEBUG) { // first memory\n    assert(start >= changetype<usize>(root) + ROOT_SIZE); // starts after root\n  }\n\n  // check if size is large enough for a free block and the tail block\n  var size = end - start;\n  if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n    return false;\n  }\n\n  // left size is total minus its own and the zero-length tail's header\n  var leftSize = size - (BLOCK_OVERHEAD << 1);\n  var left = changetype<Block>(start);\n  left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n  left.prev = null;\n  left.next = null;\n\n  // tail is a zero-length used block\n  tail = changetype<Block>(start + size - BLOCK_OVERHEAD);\n  tail.mmInfo = 0 | LEFTFREE;\n  SETTAIL(root, tail);\n\n  insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n  return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n  if (ASC_LOW_MEMORY_LIMIT) {\n    unreachable();\n    return;\n  }\n  // Here, both rounding performed in searchBlock ...\n  const halfMaxSize = BLOCK_MAXSIZE >> 1;\n  if (size < halfMaxSize) { // don't round last fl\n    const invRound = (sizeof<usize>() * 8 - 1) - SL_BITS;\n    size += (1 << (invRound - clz<usize>(size))) - 1;\n  }\n  // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n  // to merge with the tail block, that's one time, otherwise it's two times.\n  var pagesBefore = memory.size();\n  size += BLOCK_OVERHEAD << usize((<usize>pagesBefore << 16) - BLOCK_OVERHEAD != changetype<usize>(GETTAIL(root)));\n  var pagesNeeded = <i32>(((size + 0xffff) & ~0xffff) >>> 16);\n  var pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n  if (memory.grow(pagesWanted) < 0) {\n    if (memory.grow(pagesNeeded) < 0) unreachable();\n  }\n  var pagesAfter = memory.size();\n  addMemory(root, <usize>pagesBefore << 16, <usize>pagesAfter << 16);\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n  if (size >= BLOCK_MAXSIZE) throw new Error(\"allocation too large\");\n  return max<usize>((size + AL_MASK) & ~AL_MASK, BLOCK_MINSIZE); // align and ensure min size\n}\n\n/** Initilizes the root structure. */\nexport function maybeInitialize(): Root {\n  var root = ROOT;\n  if (!root) {\n    let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n    let pagesBefore = memory.size();\n    let pagesNeeded = <i32>((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n    if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n    root = changetype<Root>(rootOffset);\n    root.flMap = 0;\n    SETTAIL(root, changetype<Block>(0));\n    for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n      SETSL(root, fl, 0);\n      for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n        SETHEAD(root, fl, sl, null);\n      }\n    }\n    let memStart = (rootOffset + ROOT_SIZE + AL_MASK) & ~AL_MASK;\n    if (ASC_LOW_MEMORY_LIMIT) {\n      const memEnd = <usize>ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n      if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n      else unreachable(); // low memory limit already exceeded\n    } else {\n      addMemory(root, memStart, memory.size() << 16);\n    }\n    ROOT = root;\n  }\n  return root;\n}\n\n// @ts-ignore: decorator\n@lazy var collectLock: bool = false;\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize, id: u32): Block {\n  if (DEBUG) assert(!collectLock); // must not allocate while collecting\n  var payloadSize = prepareSize(size);\n  var block = searchBlock(root, payloadSize);\n  if (!block) {\n    if (gc.auto) {\n      if (DEBUG) collectLock = true;\n      __collect();\n      if (DEBUG) collectLock = false;\n      block = searchBlock(root, payloadSize);\n      if (!block) {\n        growMemory(root, payloadSize);\n        block = changetype<Block>(searchBlock(root, payloadSize));\n        if (DEBUG) assert(block); // must be found now\n      }\n    } else {\n      growMemory(root, payloadSize);\n      block = changetype<Block>(searchBlock(root, payloadSize));\n      if (DEBUG) assert(block); // must be found now\n    }\n  }\n  if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n  block.gcInfo = 0; // RC=0\n  block.rtId = id;\n  block.rtSize = <u32>size;\n  removeBlock(root, <Block>block);\n  prepareBlock(root, <Block>block, payloadSize);\n  if (isDefined(ASC_RTRACE)) onalloc(<Block>block);\n  return <Block>block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n  var payloadSize = prepareSize(size);\n  var blockInfo = block.mmInfo;\n\n  // possibly split and update runtime size if it still fits\n  if (payloadSize <= (blockInfo & ~TAGS_MASK)) {\n    prepareBlock(root, block, payloadSize);\n    block.rtSize = <u32>size;\n    return block;\n  }\n\n  // merge with right free block if merger is large enough\n  var right = GETRIGHT(block);\n  var rightInfo = right.mmInfo;\n  if (rightInfo & FREE) {\n    let mergeSize = (blockInfo & ~TAGS_MASK) + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n    if (mergeSize >= payloadSize) {\n      removeBlock(root, right);\n      // TODO: this can yield an intermediate block larger than BLOCK_MAXSIZE, which\n      // is immediately split though. does this trigger any assertions / issues?\n      block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n      block.rtSize = <u32>size;\n      prepareBlock(root, block, payloadSize);\n      return block;\n    }\n  }\n\n  // otherwise move the block\n  var newBlock = allocateBlock(root, size, block.rtId); // may invalidate cached blockInfo\n  newBlock.gcInfo = block.gcInfo; // keep RC\n  memory.copy(changetype<usize>(newBlock) + BLOCK_OVERHEAD, changetype<usize>(block) + BLOCK_OVERHEAD, size);\n  if (changetype<usize>(block) >= __heap_base) {\n    if (isDefined(ASC_RTRACE)) onrealloc(block, newBlock);\n    freeBlock(root, block);\n  }\n  return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n  var blockInfo = block.mmInfo;\n  block.mmInfo = blockInfo | FREE;\n  insertBlock(root, block);\n  if (isDefined(ASC_RTRACE)) onfree(block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ref: usize): Block {\n  var block = changetype<Block>(ref - BLOCK_OVERHEAD);\n  assert(\n    ref != 0 && !(ref & AL_MASK) &&  // must exist and be aligned\n    !(block.mmInfo & FREE) &&        // must be used\n    !(block.gcInfo & ~REFCOUNT_MASK) // not buffered or != BLACK\n  );\n  return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize, id: u32): usize {\n  return changetype<usize>(\n    allocateBlock(maybeInitialize(), size, id)\n  ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ref: usize, size: usize): usize {\n  return changetype<usize>(\n    reallocateBlock(maybeInitialize(), checkUsedBlock(ref), size)\n  ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ref: usize): void {\n  freeBlock(maybeInitialize(), checkUsedBlock(ref));\n}\n","/// <reference path=\"./rt/index.d.ts\" />\n\n/** Garbage collector interface. */\nexport namespace gc {\n\n  /** Can be set to `false` to disable automatic collection. Defaults to `true`. */\n  export var auto: bool = true;\n\n  /** Performs a full garbage collection cycle. */\n  export function collect(): void {\n    __collect();\n  }\n}\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport RecordedValuesIterator from \"./RecordedValuesIterator\";\nimport PercentileIterator from \"./PercentileIterator\";\n\nexport const NO_TAG = \"NO TAG\";\n\nexport abstract class AbstractHistogramBase<T, U> {\n  static identityBuilder: number;\n\n  identity: f64;\n  autoResize: boolean = false;\n\n  highestTrackableValue: u64;\n  lowestDiscernibleValue: u64;\n  numberOfSignificantValueDigits: u8;\n\n  bucketCount: u64;\n  /**\n   * Power-of-two length of linearly scaled array slots in the counts array. Long enough to hold the first sequence of\n   * entries that must be distinguished by a single unit (determined by configured precision).\n   */\n  subBucketCount: i32;\n  countsArrayLength: i32;\n  wordSizeInBytes: u64;\n\n  startTimeStampMsec: u64 = u64.MAX_VALUE;\n  endTimeStampMsec: u64 = 0;\n  tag: string = NO_TAG;\n\n  integerToDoubleValueConversionRatio: f64 = 1.0;\n\n  percentileIterator: PercentileIterator<T, U>;\n  recordedValuesIterator: RecordedValuesIterator<T, U>;\n\n  constructor() {\n    this.identity = 0;\n    this.highestTrackableValue = 0;\n    this.lowestDiscernibleValue = 0;\n    this.numberOfSignificantValueDigits = 0;\n    this.bucketCount = 0;\n    this.subBucketCount = 0;\n    this.countsArrayLength = 0;\n    this.wordSizeInBytes = 0;\n  }\n}\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nconst ulp = (x: f64): f64 =>\n  Math.abs(x - reinterpret<f64>(reinterpret<u64>(x) ^ 1));\n\nexport default ulp;\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data<u64>([\n  // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n  // used for computing 2^(k/N) for an int |k| < 150 N as\n  // double(tab[k%N] + (k << 52-BITS))\n  0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n  0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n  0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n  0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n  0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n  0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n  0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n  0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n  const\n    N      = 1 << EXP2F_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N, // 0x1.8p+52\n    Ox127f = reinterpret<f32>(0x7F000000);\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n  var xd = <f64>x;\n  var ix = reinterpret<u32>(x);\n  var ux = ix >> 20 & 0x7FF;\n  if (ux >= 0x430) {\n    // |x| >= 128 or x is nan.\n    if (ix == 0xFF800000) return 0; // x == -Inf    -> 0\n    if (ux >= 0x7F8) return x + x;  // x == Inf/NaN -> Inf/NaN\n    if (x > 0) return x * Ox127f;   // x >     0    -> HugeVal (Owerflow)\n    if (x <= -150) return 0;        // x <= -150    -> 0 (Underflow)\n  }\n\n  // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n  var kd = xd + shift;\n  var ki = reinterpret<u64>(kd);\n  var r  = xd - (kd - shift);\n  var t: u64, y: f64, s: f64;\n\n  // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += ki << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  y  = C2 * r + 1;\n  y += (C0 * r + C1) * (r  * r);\n  y *= s;\n\n  return <f32>y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n  const\n    N        = 1 << EXP2F_TABLE_BITS,\n    N_MASK   = N - 1,\n    shift    = reinterpret<f64>(0x4338000000000000),        // 0x1.8p+52\n    InvLn2N  = reinterpret<f64>(0x3FF71547652B82FE) * N,    // 0x1.71547652b82fep+0\n    Ox1p127f = reinterpret<f32>(0x7F000000);\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3) / N / N,     // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6) / N;         // 0x1.62e42ff0c52d6p-1\n\n  var xd = <f64>x;\n  var ix = reinterpret<u32>(x);\n  var ux = ix >> 20 & 0x7FF;\n  if (ux >= 0x42B) {\n    // |x| >= 88 or x is nan.\n    if (ix == 0xFF800000) return 0;                            // x == -Inf    -> 0\n    if (ux >= 0x7F8) return x + x;                             // x == Inf/NaN -> Inf/NaN\n    if (x > reinterpret<f32>(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128)  ~=  88.72 -> HugeVal (Owerflow)\n    if (x < reinterpret<f32>(0xC2CFF1B4)) return 0;            // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n  }\n\n  // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n  var z = InvLn2N * xd;\n\n  // Round and convert z to int, the result is in [-150*N, 128*N] and\n  // ideally ties-to-even rule is used, otherwise the magnitude of r\n  // can be bigger which gives larger approximation error.\n  var kd = <f64>(z + shift);\n  var ki = reinterpret<u64>(kd);\n  var r  = z - (kd - shift);\n  var s: f64, y: f64, t: u64;\n\n  // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += ki << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  z  = C0 * r + C1;\n  y  = C2 * r + 1;\n  y += z * (r * r);\n  y *= s;\n\n  return <f32>y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data<f64>([\n  reinterpret<f64>(0x3FF661EC79F8F3BE), reinterpret<f64>(0xBFDEFEC65B963019), // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n  reinterpret<f64>(0x3FF571ED4AAF883D), reinterpret<f64>(0xBFDB0B6832D4FCA4), // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n  reinterpret<f64>(0x3FF49539F0F010B0), reinterpret<f64>(0xBFD7418B0A1FB77B), // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n  reinterpret<f64>(0x3FF3C995B0B80385), reinterpret<f64>(0xBFD39DE91A6DCF7B), // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n  reinterpret<f64>(0x3FF30D190C8864A5), reinterpret<f64>(0xBFD01D9BF3F2B631), // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n  reinterpret<f64>(0x3FF25E227B0B8EA0), reinterpret<f64>(0xBFC97C1D1B3B7AF0), // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n  reinterpret<f64>(0x3FF1BB4A4A1A343F), reinterpret<f64>(0xBFC2F9E393AF3C9F), // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n  reinterpret<f64>(0x3FF12358F08AE5BA), reinterpret<f64>(0xBFB960CBBF788D5C), // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n  reinterpret<f64>(0x3FF0953F419900A7), reinterpret<f64>(0xBFAA6F9DB6475FCE), // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n  reinterpret<f64>(0x3FF0000000000000), 0,                                    // 0x1p+0,                0x0,\n  reinterpret<f64>(0x3FEE608CFD9A47AC), reinterpret<f64>(0x3FB338CA9F24F53D), // 0x1.e608cfd9a47acp-1,  0x1.338ca9f24f53dp-4,\n  reinterpret<f64>(0x3FECA4B31F026AA0), reinterpret<f64>(0x3FC476A9543891BA), // 0x1.ca4b31f026aap-1 ,  0x1.476a9543891bap-3,\n  reinterpret<f64>(0x3FEB2036576AFCE6), reinterpret<f64>(0x3FCE840B4AC4E4D2), // 0x1.b2036576afce6p-1,  0x1.e840b4ac4e4d2p-3,\n  reinterpret<f64>(0x3FE9C2D163A1AA2D), reinterpret<f64>(0x3FD40645F0C6651C), // 0x1.9c2d163a1aa2dp-1,  0x1.40645f0c6651cp-2,\n  reinterpret<f64>(0x3FE886E6037841ED), reinterpret<f64>(0x3FD88E9C2C1B9FF8), // 0x1.886e6037841edp-1,  0x1.88e9c2c1b9ff8p-2,\n  reinterpret<f64>(0x3FE767DCF5534862), reinterpret<f64>(0x3FDCE0A44EB17BCC)  // 0x1.767dcf5534862p-1,  0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n  const\n    N_MASK  = (1 << LOG2F_TABLE_BITS) - 1,\n    Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f\n\n  const\n    A0 = reinterpret<f64>(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n    A1 = reinterpret<f64>(0x3FDECABF496832E0), //  0x1.ecabf496832ep-2\n    A2 = reinterpret<f64>(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n    A3 = reinterpret<f64>(0x3FF715475F35C8B8); //  0x1.715475f35c8b8p0\n\n  var ux = reinterpret<u32>(x);\n  // Fix sign of zero with downward rounding when x==1.\n  // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n  if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n    // x < 0x1p-126 or inf or nan.\n    if (ux * 2 == 0) return -Infinity;\n    if (ux == 0x7F800000) return x; // log2(inf) == inf.\n    if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ux = reinterpret<u32>(x * Ox1p23f);\n    ux -= 23 << 23;\n  }\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp  = ux - 0x3F330000;\n  var i    = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n  var top  = tmp & 0xFF800000;\n  var iz   = ux - top;\n  var k    = <i32>tmp >> 23;\n\n  var invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  var logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n  var z    = <f64>reinterpret<f32>(iz);\n\n  // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n  var r  = z * invc - 1;\n  var y0 = logc + <f64>k;\n\n  // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n  var y  = A1 * r + A2;\n  var p  = A3 * r + y0;\n  var r2 = r * r;\n  y += A0 * r2;\n  y  = y * r2 + p;\n\n  return <f32>y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data<f64>([\n  reinterpret<f64>(0x3FF661EC79F8F3BE), reinterpret<f64>(0xBFD57BF7808CAADE), // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n  reinterpret<f64>(0x3FF571ED4AAF883D), reinterpret<f64>(0xBFD2BEF0A7C06DDB), // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n  reinterpret<f64>(0x3FF49539F0F010B0), reinterpret<f64>(0xBFD01EAE7F513A67), // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n  reinterpret<f64>(0x3FF3C995B0B80385), reinterpret<f64>(0xBFCB31D8A68224E9), // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n  reinterpret<f64>(0x3FF30D190C8864A5), reinterpret<f64>(0xBFC6574F0AC07758), // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n  reinterpret<f64>(0x3FF25E227B0B8EA0), reinterpret<f64>(0xBFC1AA2BC79C8100), // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3  ,\n  reinterpret<f64>(0x3FF1BB4A4A1A343F), reinterpret<f64>(0xBFBA4E76CE8C0E5E), // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n  reinterpret<f64>(0x3FF12358F08AE5BA), reinterpret<f64>(0xBFB1973C5A611CCC), // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n  reinterpret<f64>(0x3FF0953F419900A7), reinterpret<f64>(0xBFA252F438E10C1E), // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n  reinterpret<f64>(0x3FF0000000000000), 0,                                    // 0x1p+0,                0,\n  reinterpret<f64>(0x3FEE608CFD9A47AC), reinterpret<f64>(0x3FAAA5AA5DF25984), // 0x1.e608cfd9a47acp-1,  0x1.aa5aa5df25984p-5,\n  reinterpret<f64>(0x3FECA4B31F026AA0), reinterpret<f64>(0x3FBC5E53AA362EB4), // 0x1.ca4b31f026aap-1 ,  0x1.c5e53aa362eb4p-4,\n  reinterpret<f64>(0x3FEB2036576AFCE6), reinterpret<f64>(0x3FC526E57720DB08), // 0x1.b2036576afce6p-1,  0x1.526e57720db08p-3,\n  reinterpret<f64>(0x3FE9C2D163A1AA2D), reinterpret<f64>(0x3FCBC2860D224770), // 0x1.9c2d163a1aa2dp-1,  0x1.bc2860d22477p-3 ,\n  reinterpret<f64>(0x3FE886E6037841ED), reinterpret<f64>(0x3FD1058BC8A07EE1), // 0x1.886e6037841edp-1,  0x1.1058bc8a07ee1p-2,\n  reinterpret<f64>(0x3FE767DCF5534862), reinterpret<f64>(0x3FD4043057B6EE09)  // 0x1.767dcf5534862p-1,  0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n  const\n    N_MASK  = (1 << LOGF_TABLE_BITS) - 1,\n    Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f\n\n  const\n    Ln2 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n    A0  = reinterpret<f64>(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n    A1  = reinterpret<f64>(0x3FD5575B0BE00B6A), //  0x1.5575b0be00b6ap-2\n    A2  = reinterpret<f64>(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n  var ux = reinterpret<u32>(x);\n  // Fix sign of zero with downward rounding when x==1.\n  // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n  if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n    // x < 0x1p-126 or inf or nan.\n    if ((ux << 1) == 0) return -Infinity;\n    if (ux == 0x7F800000) return x; // log(inf) == inf.\n    if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ux = reinterpret<u32>(x * Ox1p23f);\n    ux -= 23 << 23;\n  }\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp = ux - 0x3F330000;\n  var i   = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n  var k   = <i32>tmp >> 23;\n  var iz  = ux - (tmp & 0x1FF << 23);\n\n  var invc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  var logc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n\n  var z = <f64>reinterpret<f32>(iz);\n\n  // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n  var r = z * invc - 1;\n  var y0 = logc + <f64>k * Ln2;\n\n  // Pipelined polynomial evaluation to approximate log1p(r).\n  var r2 = r * r;\n  var y  = A1 * r + A2;\n  y += A0 * r2;\n  y = y * r2 + (y0 + r);\n\n  return <f32>y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n  return (ux << 1) - 1 >= (<u32>0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n  var e = iy >> 23 & 0xFF;\n  if (e < 0x7F     ) return 0;\n  if (e > 0x7F + 23) return 2;\n  e = 1 << (0x7F + 23 - e);\n  if (iy & (e - 1)) return 0;\n  if (iy &  e     ) return 1;\n  return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n  const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n  const\n    A0 = reinterpret<f64>(0x3FD27616C9496E0B), //  0x1.27616c9496e0bp-2\n    A1 = reinterpret<f64>(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n    A2 = reinterpret<f64>(0x3FDEC70A6CA7BADD), //  0x1.ec70a6ca7baddp-2\n    A3 = reinterpret<f64>(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n    A4 = reinterpret<f64>(0x3FF71547652AB82B); //  0x1.71547652ab82bp+0\n\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp  = ux - 0x3F330000;\n  var i    = <usize>((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n  var top  = tmp & 0xFF800000;\n  var uz   = ux - top;\n  var k    = <i32>(<i32>top >> 23);\n\n  var invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  var logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n  var z    = <f64>reinterpret<f32>(uz);\n\n  // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n  var r  = z * invc - 1;\n  var y0 = logc + <f64>k;\n\n  // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n  var y = A0 * r + A1;\n  var p = A2 * r + A3;\n  var q = A4 * r + y0;\n\n  r *= r;\n  q += p * r;\n  y  = y * (r * r) + q;\n\n  return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not.  The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n  const\n    N      = 1 << EXP2F_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p+52\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n  // x = k/N + r with r in [-1/(2N), 1/(2N)]\n  var kd = <f64>(xd + shift);\n  var ki = reinterpret<u64>(kd);\n  var r  = xd - (kd - shift);\n  var t: u64, z: f64, y: f64, s: f64;\n\n  // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  z  = C0 * r + C1;\n  y  = C2 * r + 1;\n  y += z * (r * r);\n  y *= s;\n  return <f32>y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n  return select<f32>(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n  return xflowf(sign, reinterpret<f32>(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n  return xflowf(sign, reinterpret<f32>(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n  const\n    Ox1p23f     = reinterpret<f32>(0x4B000000), // 0x1p23f\n    UPPER_LIMIT = reinterpret<f64>(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n    LOWER_LIMIT = -150.0,\n    SIGN_BIAS   = 1 << (EXP2F_TABLE_BITS + 11);\n\n  var signBias: u32 = 0;\n  var ix = reinterpret<u32>(x);\n  var iy = reinterpret<u32>(y);\n  var ny = 0;\n\n  if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n    // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n    if (ny) {\n      if ((iy << 1) == 0) return 1.0;\n      if (ix == 0x3F800000) return NaN; // original: 1.0\n      if ((ix << 1) > (<u32>0x7F800000 << 1) || (iy << 1) > (<u32>0x7F800000 << 1)) return x + y;\n      if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n      if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n      return y * y;\n    }\n    if (zeroinfnanf(ix)) {\n      let x2 = x * x;\n      if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n      return iy >> 31 ? 1 / x2 : x2;\n    }\n    // x and y are non-zero finite.\n    if (ix >> 31) {\n      // Finite x < 0.\n      let yint = checkintf(iy);\n      if (yint == 0) return (x - x) / (x - x);\n      if (yint == 1) signBias = SIGN_BIAS;\n      ix &= 0x7FFFFFFF;\n    }\n    if (ix < 0x00800000) {\n      // Normalize subnormal x so exponent becomes negative.\n      ix = reinterpret<u32>(x * Ox1p23f);\n      ix &= 0x7FFFFFFF;\n      ix -= 23 << 23;\n    }\n  }\n  var logx = log2f_inline(ix);\n  var ylogx = y * logx; // cannot overflow, y is single prec.\n  if ((reinterpret<u64>(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret<u64>(126.0) >> 47\n    // |y * log(x)| >= 126\n    if (ylogx  > UPPER_LIMIT) return oflowf(signBias); // overflow\n    if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n  }\n  return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data<u64>([\n  0x0000000000000000, 0x3FF0000000000000,\n  0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n  0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n  0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n  0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n  0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n  0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n  0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n  0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n  0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n  0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n  0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n  0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n  0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n  0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n  0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n  0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n  0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n  0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n  0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n  0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n  0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n  0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n  0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n  0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n  0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n  0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n  0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n  0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n  0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n  0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n  0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n  0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n  0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n  0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n  0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n  0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n  0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n  0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n  0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n  0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n  0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n  0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n  0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n  0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n  0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n  0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n  0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n  0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n  0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n  0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n  0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n  0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n  0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n  0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n  0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n  0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n  0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n  0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n  0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n  0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n  0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n  0xBC93CEDD78565858, 0x3FEEA23882552225,\n  0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n  0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n  0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n  0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n  0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n  0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n  0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n  0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n  0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n  0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n  0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n  0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n  0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n  0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n  0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n  0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n  0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n  0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n  0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n  0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n  0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n  0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n  0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n  0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n  0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n  0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n  0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n  0xBC87C50422622263, 0x3FEECC667B5DE565,\n  0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n  0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n  0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n  0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n  0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n  0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n  0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n  0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n  0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n  0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n  0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n  0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n  0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n  0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n  0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n  0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n  0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n  0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n  0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n  0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n  0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n  0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n  0xBC82919E2040220F, 0x3FEF60E316C98398,\n  0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n  0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n  0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n  0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n  0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n  0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n  0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n  0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n  0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n  0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n  0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n  0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n  0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n  0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double.  (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n  const\n    Ox1p_1022 = reinterpret<f64>(0x0010000000000000), // 0x1p-1022\n    Ox1p1009  = reinterpret<f64>(0x7F00000000000000); // 0x1p1009\n\n  var scale: f64;\n  if (!(ki & 0x80000000)) {\n    // k > 0, the exponent of scale might have overflowed by <= 460.\n    sbits -= u64(1009) << 52;\n    scale = reinterpret<f64>(sbits);\n    return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n  }\n  // k < 0, need special care in the subnormal range.\n  sbits += u64(1022) << 52;\n  // Note: sbits is signed scale.\n  scale = reinterpret<f64>(sbits);\n  var y = scale + scale * tmp;\n  if (abs(y) < 1.0) {\n    // Round y to the right precision before scaling it into the subnormal\n    // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n    // E is the worst-case ulp error outside the subnormal range.  So this\n    // is only useful if the goal is better than 1 ulp worst-case error.\n    let one = copysign(1.0, y);\n    let lo = scale - y + scale * tmp;\n    let hi = one + y;\n    lo = one - hi + y + lo;\n    y  = (hi + lo) - one;\n    // Fix the sign of 0.\n    if (y == 0.0) y = reinterpret<f64>(sbits & 0x8000000000000000);\n  }\n  return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n  const\n    N      = 1 << EXP_TABLE_BITS,\n    N_MASK = N - 1;\n\n  const\n    InvLn2N   = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n    NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000),     // -0x1.62e42fefa0000p-8\n    NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A),     // -0x1.cf79abc9e3b3ap-47\n    shift     = reinterpret<f64>(0x4338000000000000);     // 0x1.8p52;\n\n  const\n    C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n    C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n    C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n    C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n  var ux = reinterpret<u64>(x);\n  var abstop = <u32>(ux >> 52 & 0x7FF);\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) return 1;\n    if (abstop >= 0x409) {\n      if (ux == 0xFFF0000000000000) return 0;\n      if (abstop >= 0x7FF) return 1.0 + x;\n      return select<f64>(0, Infinity, ux >> 63);\n    }\n    // Large x is special cased below.\n    abstop = 0;\n  }\n\n  // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n  // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n  var z = InvLn2N * x;\n  // #if TOINT_INTRINSICS\n  // \tkd = roundtoint(z);\n  // \tki = converttoint(z);\n  // #elif EXP_USE_TOINT_NARROW\n  // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n  // var kd = z + shift;\n  // var ki = reinterpret<u64>(kd) >> 16;\n  // var kd = <f64><i32>ki;\n  // #else\n  // z - kd is in [-1, 1] in non-nearest rounding modes.\n  var kd = z + shift;\n  var ki = reinterpret<u64>(kd);\n  kd -= shift;\n  // #endif\n  var r = x + kd * NegLn2hiN + kd * NegLn2loN;\n  // 2^(k/N) ~= scale * (1 + tail).\n  var idx = <usize>((ki & N_MASK) << 1);\n  var top = ki << (52 - EXP_TABLE_BITS);\n\n  var tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()))); // T[idx]\n  // This is only a valid scale when -1023*N < k < 1024*N\n  var sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]\n  // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  var r2 = r * r;\n  // Without fma the worst case error is 0.25/N ulp larger.\n  // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n  var tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase(tmp, sbits, ki);\n  var scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n  // is no spurious underflow here even without fma.\n  return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding.  The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double.  (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n  const Ox1p_1022 = reinterpret<f64>(0x10000000000000); // 0x1p-1022\n  var scale: f64;\n  if ((ki & 0x80000000) == 0) {\n    // k > 0, the exponent of scale might have overflowed by 1\n    sbits -= u64(1) << 52;\n    scale = reinterpret<f64>(sbits);\n    return 2 * (scale * tmp + scale);\n  }\n  // k < 0, need special care in the subnormal range\n  sbits += u64(1022) << 52;\n  scale = reinterpret<f64>(sbits);\n  var y = scale * tmp + scale;\n  if (y < 1.0) {\n    // Round y to the right precision before scaling it into the subnormal\n    // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n    // E is the worst-case ulp error outside the subnormal range. So this\n    // is only useful if the goal is better than 1 ulp worst-case error.\n    let hi: f64, lo: f64;\n    lo = scale - y + scale * tmp;\n    hi = 1.0 + y;\n    lo = 1.0 - hi + y + lo;\n    y = (hi + lo) - 1.0;\n  }\n  return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n  const\n    N      = 1 << EXP_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p52\n\n  const\n    C1 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n    C2 = reinterpret<f64>(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n    C3 = reinterpret<f64>(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n    C4 = reinterpret<f64>(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n    C5 = reinterpret<f64>(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n  var ux = reinterpret<u64>(x);\n  var abstop = <u32>(ux >> 52 & 0x7ff);\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n    if (abstop >= 0x409) {\n      if (ux == 0xFFF0000000000000) return 0;\n      if (abstop >= 0x7FF) return 1.0 + x;\n      if (!(ux >> 63)) return Infinity;\n      else if (ux >= 0xC090CC0000000000) return 0;\n    }\n    if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n  }\n\n  // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n  // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n  var kd = x + shift;\n  var ki = reinterpret<u64>(kd);\n  kd -= shift; // k/N for int k\n  var r = x - kd;\n  // 2^(k/N) ~= scale * (1 + tail)\n  var idx = <usize>((ki & N_MASK) << 1);\n  var top = ki << (52 - EXP_TABLE_BITS);\n\n  var tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 0 << alignof<u64>())); // T[idx])\n  // This is only a valid scale when -1023*N < k < 1024*N\n  var sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]\n  // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution\n  var r2 = r * r;\n  // Without fma the worst case error is 0.5/N ulp larger.\n  // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n  var tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase2(tmp, sbits, ki);\n  var scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n  // is no spurious underflow here even without fma.\n  return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n  x = 2^k z\n  log2(x) = k + log2(c) + log2(z/c)\n  log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = (double)log2(c)\n  tab2[i].chi = (double)c\n  tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n  1) the rounding error in 0x1.8p10 + logc is 0,\n  2) the rounding error in z - chi - clo is < 0x1p-64 and\n  3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data<f64>([\n  //            invc                  ,                logc\n  reinterpret<f64>(0x3FF724286BB1ACF8), reinterpret<f64>(0xBFE1095FEECDB000),\n  reinterpret<f64>(0x3FF6E1F766D2CCA1), reinterpret<f64>(0xBFE08494BD76D000),\n  reinterpret<f64>(0x3FF6A13D0E30D48A), reinterpret<f64>(0xBFE00143AEE8F800),\n  reinterpret<f64>(0x3FF661EC32D06C85), reinterpret<f64>(0xBFDEFEC5360B4000),\n  reinterpret<f64>(0x3FF623FA951198F8), reinterpret<f64>(0xBFDDFDD91AB7E000),\n  reinterpret<f64>(0x3FF5E75BA4CF026C), reinterpret<f64>(0xBFDCFFAE0CC79000),\n  reinterpret<f64>(0x3FF5AC055A214FB8), reinterpret<f64>(0xBFDC043811FDA000),\n  reinterpret<f64>(0x3FF571ED0F166E1E), reinterpret<f64>(0xBFDB0B67323AE000),\n  reinterpret<f64>(0x3FF53909590BF835), reinterpret<f64>(0xBFDA152F5A2DB000),\n  reinterpret<f64>(0x3FF5014FED61ADDD), reinterpret<f64>(0xBFD9217F5AF86000),\n  reinterpret<f64>(0x3FF4CAB88E487BD0), reinterpret<f64>(0xBFD8304DB0719000),\n  reinterpret<f64>(0x3FF49539B4334FEE), reinterpret<f64>(0xBFD74189F9A9E000),\n  reinterpret<f64>(0x3FF460CBDFAFD569), reinterpret<f64>(0xBFD6552BB5199000),\n  reinterpret<f64>(0x3FF42D664EE4B953), reinterpret<f64>(0xBFD56B23A29B1000),\n  reinterpret<f64>(0x3FF3FB01111DD8A6), reinterpret<f64>(0xBFD483650F5FA000),\n  reinterpret<f64>(0x3FF3C995B70C5836), reinterpret<f64>(0xBFD39DE937F6A000),\n  reinterpret<f64>(0x3FF3991C4AB6FD4A), reinterpret<f64>(0xBFD2BAA1538D6000),\n  reinterpret<f64>(0x3FF3698E0CE099B5), reinterpret<f64>(0xBFD1D98340CA4000),\n  reinterpret<f64>(0x3FF33AE48213E7B2), reinterpret<f64>(0xBFD0FA853A40E000),\n  reinterpret<f64>(0x3FF30D191985BDB1), reinterpret<f64>(0xBFD01D9C32E73000),\n  reinterpret<f64>(0x3FF2E025CAB271D7), reinterpret<f64>(0xBFCE857DA2FA6000),\n  reinterpret<f64>(0x3FF2B404CF13CD82), reinterpret<f64>(0xBFCCD3C8633D8000),\n  reinterpret<f64>(0x3FF288B02C7CCB50), reinterpret<f64>(0xBFCB26034C14A000),\n  reinterpret<f64>(0x3FF25E2263944DE5), reinterpret<f64>(0xBFC97C1C2F4FE000),\n  reinterpret<f64>(0x3FF234563D8615B1), reinterpret<f64>(0xBFC7D6023F800000),\n  reinterpret<f64>(0x3FF20B46E33EAF38), reinterpret<f64>(0xBFC633A71A05E000),\n  reinterpret<f64>(0x3FF1E2EEFDCDA3DD), reinterpret<f64>(0xBFC494F5E9570000),\n  reinterpret<f64>(0x3FF1BB4A580B3930), reinterpret<f64>(0xBFC2F9E424E0A000),\n  reinterpret<f64>(0x3FF19453847F2200), reinterpret<f64>(0xBFC162595AFDC000),\n  reinterpret<f64>(0x3FF16E06C0D5D73C), reinterpret<f64>(0xBFBF9C9A75BD8000),\n  reinterpret<f64>(0x3FF1485F47B7E4C2), reinterpret<f64>(0xBFBC7B575BF9C000),\n  reinterpret<f64>(0x3FF12358AD0085D1), reinterpret<f64>(0xBFB960C60FF48000),\n  reinterpret<f64>(0x3FF0FEF00F532227), reinterpret<f64>(0xBFB64CE247B60000),\n  reinterpret<f64>(0x3FF0DB2077D03A8F), reinterpret<f64>(0xBFB33F78B2014000),\n  reinterpret<f64>(0x3FF0B7E6D65980D9), reinterpret<f64>(0xBFB0387D1A42C000),\n  reinterpret<f64>(0x3FF0953EFE7B408D), reinterpret<f64>(0xBFAA6F9208B50000),\n  reinterpret<f64>(0x3FF07325CAC53B83), reinterpret<f64>(0xBFA47A954F770000),\n  reinterpret<f64>(0x3FF05197E40D1B5C), reinterpret<f64>(0xBF9D23A8C50C0000),\n  reinterpret<f64>(0x3FF03091C1208EA2), reinterpret<f64>(0xBF916A2629780000),\n  reinterpret<f64>(0x3FF0101025B37E21), reinterpret<f64>(0xBF7720F8D8E80000),\n  reinterpret<f64>(0x3FEFC07EF9CAA76B), reinterpret<f64>(0x3F86FE53B1500000),\n  reinterpret<f64>(0x3FEF4465D3F6F184), reinterpret<f64>(0x3FA11CCCE10F8000),\n  reinterpret<f64>(0x3FEECC079F84107F), reinterpret<f64>(0x3FAC4DFC8C8B8000),\n  reinterpret<f64>(0x3FEE573A99975AE8), reinterpret<f64>(0x3FB3AA321E574000),\n  reinterpret<f64>(0x3FEDE5D6F0BD3DE6), reinterpret<f64>(0x3FB918A0D08B8000),\n  reinterpret<f64>(0x3FED77B681FF38B3), reinterpret<f64>(0x3FBE72E9DA044000),\n  reinterpret<f64>(0x3FED0CB5724DE943), reinterpret<f64>(0x3FC1DCD2507F6000),\n  reinterpret<f64>(0x3FECA4B2DC0E7563), reinterpret<f64>(0x3FC476AB03DEA000),\n  reinterpret<f64>(0x3FEC3F8EE8D6CB51), reinterpret<f64>(0x3FC7074377E22000),\n  reinterpret<f64>(0x3FEBDD2B4F020C4C), reinterpret<f64>(0x3FC98EDE8BA94000),\n  reinterpret<f64>(0x3FEB7D6C006015CA), reinterpret<f64>(0x3FCC0DB86AD2E000),\n  reinterpret<f64>(0x3FEB20366E2E338F), reinterpret<f64>(0x3FCE840AAFCEE000),\n  reinterpret<f64>(0x3FEAC57026295039), reinterpret<f64>(0x3FD0790AB4678000),\n  reinterpret<f64>(0x3FEA6D01BC2731DD), reinterpret<f64>(0x3FD1AC056801C000),\n  reinterpret<f64>(0x3FEA16D3BC3FF18B), reinterpret<f64>(0x3FD2DB11D4FEE000),\n  reinterpret<f64>(0x3FE9C2D14967FEAD), reinterpret<f64>(0x3FD406464EC58000),\n  reinterpret<f64>(0x3FE970E4F47C9902), reinterpret<f64>(0x3FD52DBE093AF000),\n  reinterpret<f64>(0x3FE920FB3982BCF2), reinterpret<f64>(0x3FD651902050D000),\n  reinterpret<f64>(0x3FE8D30187F759F1), reinterpret<f64>(0x3FD771D2CDEAF000),\n  reinterpret<f64>(0x3FE886E5EBB9F66D), reinterpret<f64>(0x3FD88E9C857D9000),\n  reinterpret<f64>(0x3FE83C97B658B994), reinterpret<f64>(0x3FD9A80155E16000),\n  reinterpret<f64>(0x3FE7F405FFC61022), reinterpret<f64>(0x3FDABE186ED3D000),\n  reinterpret<f64>(0x3FE7AD22181415CA), reinterpret<f64>(0x3FDBD0F2AEA0E000),\n  reinterpret<f64>(0x3FE767DCF99EFF8C), reinterpret<f64>(0x3FDCE0A43DBF4000)\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data<f64>([\n  //              chi                 ,                 clo\n  reinterpret<f64>(0x3FE6200012B90A8E), reinterpret<f64>(0x3C8904AB0644B605),\n  reinterpret<f64>(0x3FE66000045734A6), reinterpret<f64>(0x3C61FF9BEA62F7A9),\n  reinterpret<f64>(0x3FE69FFFC325F2C5), reinterpret<f64>(0x3C827ECFCB3C90BA),\n  reinterpret<f64>(0x3FE6E00038B95A04), reinterpret<f64>(0x3C88FF8856739326),\n  reinterpret<f64>(0x3FE71FFFE09994E3), reinterpret<f64>(0x3C8AFD40275F82B1),\n  reinterpret<f64>(0x3FE7600015590E10), reinterpret<f64>(0xBC72FD75B4238341),\n  reinterpret<f64>(0x3FE7A00012655BD5), reinterpret<f64>(0x3C7808E67C242B76),\n  reinterpret<f64>(0x3FE7E0003259E9A6), reinterpret<f64>(0xBC6208E426F622B7),\n  reinterpret<f64>(0x3FE81FFFEDB4B2D2), reinterpret<f64>(0xBC8402461EA5C92F),\n  reinterpret<f64>(0x3FE860002DFAFCC3), reinterpret<f64>(0x3C6DF7F4A2F29A1F),\n  reinterpret<f64>(0x3FE89FFFF78C6B50), reinterpret<f64>(0xBC8E0453094995FD),\n  reinterpret<f64>(0x3FE8E00039671566), reinterpret<f64>(0xBC8A04F3BEC77B45),\n  reinterpret<f64>(0x3FE91FFFE2BF1745), reinterpret<f64>(0xBC77FA34400E203C),\n  reinterpret<f64>(0x3FE95FFFCC5C9FD1), reinterpret<f64>(0xBC76FF8005A0695D),\n  reinterpret<f64>(0x3FE9A0003BBA4767), reinterpret<f64>(0x3C70F8C4C4EC7E03),\n  reinterpret<f64>(0x3FE9DFFFE7B92DA5), reinterpret<f64>(0x3C8E7FD9478C4602),\n  reinterpret<f64>(0x3FEA1FFFD72EFDAF), reinterpret<f64>(0xBC6A0C554DCDAE7E),\n  reinterpret<f64>(0x3FEA5FFFDE04FF95), reinterpret<f64>(0x3C867DA98CE9B26B),\n  reinterpret<f64>(0x3FEA9FFFCA5E8D2B), reinterpret<f64>(0xBC8284C9B54C13DE),\n  reinterpret<f64>(0x3FEADFFFDDAD03EA), reinterpret<f64>(0x3C5812C8EA602E3C),\n  reinterpret<f64>(0x3FEB1FFFF10D3D4D), reinterpret<f64>(0xBC8EFADDAD27789C),\n  reinterpret<f64>(0x3FEB5FFFCE21165A), reinterpret<f64>(0x3C53CB1719C61237),\n  reinterpret<f64>(0x3FEB9FFFD950E674), reinterpret<f64>(0x3C73F7D94194CE00),\n  reinterpret<f64>(0x3FEBE000139CA8AF), reinterpret<f64>(0x3C750AC4215D9BC0),\n  reinterpret<f64>(0x3FEC20005B46DF99), reinterpret<f64>(0x3C6BEEA653E9C1C9),\n  reinterpret<f64>(0x3FEC600040B9F7AE), reinterpret<f64>(0xBC7C079F274A70D6),\n  reinterpret<f64>(0x3FECA0006255FD8A), reinterpret<f64>(0xBC7A0B4076E84C1F),\n  reinterpret<f64>(0x3FECDFFFD94C095D), reinterpret<f64>(0x3C88F933F99AB5D7),\n  reinterpret<f64>(0x3FED1FFFF975D6CF), reinterpret<f64>(0xBC582C08665FE1BE),\n  reinterpret<f64>(0x3FED5FFFA2561C93), reinterpret<f64>(0xBC7B04289BD295F3),\n  reinterpret<f64>(0x3FED9FFF9D228B0C), reinterpret<f64>(0x3C870251340FA236),\n  reinterpret<f64>(0x3FEDE00065BC7E16), reinterpret<f64>(0xBC75011E16A4D80C),\n  reinterpret<f64>(0x3FEE200002F64791), reinterpret<f64>(0x3C89802F09EF62E0),\n  reinterpret<f64>(0x3FEE600057D7A6D8), reinterpret<f64>(0xBC7E0B75580CF7FA),\n  reinterpret<f64>(0x3FEEA00027EDC00C), reinterpret<f64>(0xBC8C848309459811),\n  reinterpret<f64>(0x3FEEE0006CF5CB7C), reinterpret<f64>(0xBC8F8027951576F4),\n  reinterpret<f64>(0x3FEF2000782B7DCC), reinterpret<f64>(0xBC8F81D97274538F),\n  reinterpret<f64>(0x3FEF6000260C450A), reinterpret<f64>(0xBC4071002727FFDC),\n  reinterpret<f64>(0x3FEF9FFFE88CD533), reinterpret<f64>(0xBC581BDCE1FDA8B0),\n  reinterpret<f64>(0x3FEFDFFFD50F8689), reinterpret<f64>(0x3C87F91ACB918E6E),\n  reinterpret<f64>(0x3FF0200004292367), reinterpret<f64>(0x3C9B7FF365324681),\n  reinterpret<f64>(0x3FF05FFFE3E3D668), reinterpret<f64>(0x3C86FA08DDAE957B),\n  reinterpret<f64>(0x3FF0A0000A85A757), reinterpret<f64>(0xBC57E2DE80D3FB91),\n  reinterpret<f64>(0x3FF0E0001A5F3FCC), reinterpret<f64>(0xBC91823305C5F014),\n  reinterpret<f64>(0x3FF11FFFF8AFBAF5), reinterpret<f64>(0xBC8BFABB6680BAC2),\n  reinterpret<f64>(0x3FF15FFFE54D91AD), reinterpret<f64>(0xBC9D7F121737E7EF),\n  reinterpret<f64>(0x3FF1A00011AC36E1), reinterpret<f64>(0x3C9C000A0516F5FF),\n  reinterpret<f64>(0x3FF1E00019C84248), reinterpret<f64>(0xBC9082FBE4DA5DA0),\n  reinterpret<f64>(0x3FF220000FFE5E6E), reinterpret<f64>(0xBC88FDD04C9CFB43),\n  reinterpret<f64>(0x3FF26000269FD891), reinterpret<f64>(0x3C8CFE2A7994D182),\n  reinterpret<f64>(0x3FF2A00029A6E6DA), reinterpret<f64>(0xBC700273715E8BC5),\n  reinterpret<f64>(0x3FF2DFFFE0293E39), reinterpret<f64>(0x3C9B7C39DAB2A6F9),\n  reinterpret<f64>(0x3FF31FFFF7DCF082), reinterpret<f64>(0x3C7DF1336EDC5254),\n  reinterpret<f64>(0x3FF35FFFF05A8B60), reinterpret<f64>(0xBC9E03564CCD31EB),\n  reinterpret<f64>(0x3FF3A0002E0EAECC), reinterpret<f64>(0x3C75F0E74BD3A477),\n  reinterpret<f64>(0x3FF3E000043BB236), reinterpret<f64>(0x3C9C7DCB149D8833),\n  reinterpret<f64>(0x3FF4200002D187FF), reinterpret<f64>(0x3C7E08AFCF2D3D28),\n  reinterpret<f64>(0x3FF460000D387CB1), reinterpret<f64>(0x3C820837856599A6),\n  reinterpret<f64>(0x3FF4A00004569F89), reinterpret<f64>(0xBC89FA5C904FBCD2),\n  reinterpret<f64>(0x3FF4E000043543F3), reinterpret<f64>(0xBC781125ED175329),\n  reinterpret<f64>(0x3FF51FFFCC027F0F), reinterpret<f64>(0x3C9883D8847754DC),\n  reinterpret<f64>(0x3FF55FFFFD87B36F), reinterpret<f64>(0xBC8709E731D02807),\n  reinterpret<f64>(0x3FF59FFFF21DF7BA), reinterpret<f64>(0x3C87F79F68727B02),\n  reinterpret<f64>(0x3FF5DFFFEBFC3481), reinterpret<f64>(0xBC9180902E30E93E)\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n  const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n  const\n    LO: u64 = 0x3FEEA4AF00000000, // reinterpret<u64>(1.0 - 0x1.5b51p-5)\n    HI: u64 = 0x3FF0B55900000000; // reinterpret<u64>(1.0 + 0x1.6ab2p-5)\n\n  const\n    InvLn2hi = reinterpret<f64>(0x3FF7154765200000), // 0x1.7154765200000p+0\n    InvLn2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n    Ox1p52   = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  const\n    B0 = reinterpret<f64>(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n    B1 = reinterpret<f64>(0x3FDEC709DC3A03F7), //  0x1.ec709dc3a03f7p-2\n    B2 = reinterpret<f64>(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n    B3 = reinterpret<f64>(0x3FD2776C50F05BE4), //  0x1.2776c50f05be4p-2\n    B4 = reinterpret<f64>(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n    B5 = reinterpret<f64>(0x3FCA61761EC4E736), //  0x1.a61761ec4e736p-3\n    B6 = reinterpret<f64>(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n    B7 = reinterpret<f64>(0x3FC484D154F01B4A), //  0x1.484d154f01b4ap-3\n    B8 = reinterpret<f64>(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n    B9 = reinterpret<f64>(0x3FC0B32F285AEE66); //  0x1.0b32f285aee66p-3\n\n  const\n    A0 = reinterpret<f64>(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n    A1 = reinterpret<f64>(0x3FDEC709DC3A04BE), //  0x1.ec709dc3a04bep-2\n    A2 = reinterpret<f64>(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n    A3 = reinterpret<f64>(0x3FD2776C50034C48), //  0x1.2776c50034c48p-2\n    A4 = reinterpret<f64>(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n    A5 = reinterpret<f64>(0x3FCA6225E117F92E); //  0x1.a6225e117f92ep-3\n\n  var ix = reinterpret<u64>(x);\n  if (ix - LO < HI - LO) {\n    let r = x - 1.0;\n    // #if __FP_FAST_FMA\n    //     hi = r * InvLn2hi;\n    //     lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n    // #else\n    let rhi = reinterpret<f64>(reinterpret<u64>(r) & 0xFFFFFFFF00000000);\n    let rlo = r - rhi;\n    let hi  = rhi * InvLn2hi;\n    let lo  = rlo * InvLn2hi + r * InvLn2lo;\n    // #endif\n    let r2 = r * r; // rounding error: 0x1p-62\n    let r4 = r2 * r2;\n    // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n    let p = r2 * (B0 + r * B1);\n    let y = hi + p;\n    lo += hi - y + p;\n    lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n          r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n    return y + lo;\n  }\n  var top = <u32>(ix >> 48);\n  if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n    // x < 0x1p-1022 or inf or nan.\n    if ((ix << 1) == 0) return -1.0 / (x * x);\n    if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n    if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ix = reinterpret<u64>(x * Ox1p52);\n    ix -= u64(52) << 52;\n  }\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp  = ix - 0x3FE6000000000000;\n  var i    = <usize>((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n  var k    = <i64>tmp >> 52;\n  var iz   = ix - (tmp & 0xFFF0000000000000);\n\n  var invc = load<f64>(LOG2_DATA_TAB1  + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].invc;\n  var logc = load<f64>(LOG2_DATA_TAB1  + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].logc;\n  var z    = reinterpret<f64>(iz);\n  var kd   = <f64>k;\n\n  // log2(x) = log2(z/c) + log2(c) + k.\n  // r ~= z/c - 1, |r| < 1/(2*N).\n  // #if __FP_FAST_FMA\n  // \t// rounding error: 0x1p-55/N.\n  // \tr = __builtin_fma(z, invc, -1.0);\n  // \tt1 = r * InvLn2hi;\n  // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n  // #else\n  // rounding error: 0x1p-55/N + 0x1p-65.\n  var chi = load<f64>(LOG2_DATA_TAB2 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].chi;\n  var clo = load<f64>(LOG2_DATA_TAB2 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].clo;\n\n  var r   = (z - chi - clo) * invc;\n  var rhi = reinterpret<f64>(reinterpret<u64>(r) & 0xFFFFFFFF00000000);\n  var rlo = r - rhi;\n  var t1  = rhi * InvLn2hi;\n  var t2  = rlo * InvLn2hi + r * InvLn2lo;\n  // #endif\n\n  // hi + lo = r/ln2 + log2(c) + k\n  var t3 = kd + logc;\n  var hi = t3 + t1;\n  var lo = t3 - hi + t1 + t2;\n\n  // log2(r+1) = r/ln2 + r^2*poly(r)\n  // Evaluation is optimized assuming superscalar pipelined execution\n  var r2 = r * r; // rounding error: 0x1p-54/N^2\n  // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n  // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n  var p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n  return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n  x = 2^k z\n  log(x) = k ln2 + log(c) + log(z/c)\n  log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = (double)log(c)\n  tab2[i].chi = (double)c\n  tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n  1) the rounding error in 0x1.8p9 + logc is 0,\n  2) the rounding error in z - chi - clo is < 0x1p-66 and\n  3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data<f64>([\n  //              invc                ,                 logc\n  reinterpret<f64>(0x3FF734F0C3E0DE9F), reinterpret<f64>(0xBFD7CC7F79E69000),\n  reinterpret<f64>(0x3FF713786A2CE91F), reinterpret<f64>(0xBFD76FEEC20D0000),\n  reinterpret<f64>(0x3FF6F26008FAB5A0), reinterpret<f64>(0xBFD713E31351E000),\n  reinterpret<f64>(0x3FF6D1A61F138C7D), reinterpret<f64>(0xBFD6B85B38287800),\n  reinterpret<f64>(0x3FF6B1490BC5B4D1), reinterpret<f64>(0xBFD65D5590807800),\n  reinterpret<f64>(0x3FF69147332F0CBA), reinterpret<f64>(0xBFD602D076180000),\n  reinterpret<f64>(0x3FF6719F18224223), reinterpret<f64>(0xBFD5A8CA86909000),\n  reinterpret<f64>(0x3FF6524F99A51ED9), reinterpret<f64>(0xBFD54F4356035000),\n  reinterpret<f64>(0x3FF63356AA8F24C4), reinterpret<f64>(0xBFD4F637C36B4000),\n  reinterpret<f64>(0x3FF614B36B9DDC14), reinterpret<f64>(0xBFD49DA7FDA85000),\n  reinterpret<f64>(0x3FF5F66452C65C4C), reinterpret<f64>(0xBFD445923989A800),\n  reinterpret<f64>(0x3FF5D867B5912C4F), reinterpret<f64>(0xBFD3EDF439B0B800),\n  reinterpret<f64>(0x3FF5BABCCB5B90DE), reinterpret<f64>(0xBFD396CE448F7000),\n  reinterpret<f64>(0x3FF59D61F2D91A78), reinterpret<f64>(0xBFD3401E17BDA000),\n  reinterpret<f64>(0x3FF5805612465687), reinterpret<f64>(0xBFD2E9E2EF468000),\n  reinterpret<f64>(0x3FF56397CEE76BD3), reinterpret<f64>(0xBFD2941B3830E000),\n  reinterpret<f64>(0x3FF54725E2A77F93), reinterpret<f64>(0xBFD23EC58CDA8800),\n  reinterpret<f64>(0x3FF52AFF42064583), reinterpret<f64>(0xBFD1E9E129279000),\n  reinterpret<f64>(0x3FF50F22DBB2BDDF), reinterpret<f64>(0xBFD1956D2B48F800),\n  reinterpret<f64>(0x3FF4F38F4734DED7), reinterpret<f64>(0xBFD141679AB9F800),\n  reinterpret<f64>(0x3FF4D843CFDE2840), reinterpret<f64>(0xBFD0EDD094EF9800),\n  reinterpret<f64>(0x3FF4BD3EC078A3C8), reinterpret<f64>(0xBFD09AA518DB1000),\n  reinterpret<f64>(0x3FF4A27FC3E0258A), reinterpret<f64>(0xBFD047E65263B800),\n  reinterpret<f64>(0x3FF4880524D48434), reinterpret<f64>(0xBFCFEB224586F000),\n  reinterpret<f64>(0x3FF46DCE1B192D0B), reinterpret<f64>(0xBFCF474A7517B000),\n  reinterpret<f64>(0x3FF453D9D3391854), reinterpret<f64>(0xBFCEA4443D103000),\n  reinterpret<f64>(0x3FF43A2744B4845A), reinterpret<f64>(0xBFCE020D44E9B000),\n  reinterpret<f64>(0x3FF420B54115F8FB), reinterpret<f64>(0xBFCD60A22977F000),\n  reinterpret<f64>(0x3FF40782DA3EF4B1), reinterpret<f64>(0xBFCCC00104959000),\n  reinterpret<f64>(0x3FF3EE8F5D57FE8F), reinterpret<f64>(0xBFCC202956891000),\n  reinterpret<f64>(0x3FF3D5D9A00B4CE9), reinterpret<f64>(0xBFCB81178D811000),\n  reinterpret<f64>(0x3FF3BD60C010C12B), reinterpret<f64>(0xBFCAE2C9CCD3D000),\n  reinterpret<f64>(0x3FF3A5242B75DAB8), reinterpret<f64>(0xBFCA45402E129000),\n  reinterpret<f64>(0x3FF38D22CD9FD002), reinterpret<f64>(0xBFC9A877681DF000),\n  reinterpret<f64>(0x3FF3755BC5847A1C), reinterpret<f64>(0xBFC90C6D69483000),\n  reinterpret<f64>(0x3FF35DCE49AD36E2), reinterpret<f64>(0xBFC87120A645C000),\n  reinterpret<f64>(0x3FF34679984DD440), reinterpret<f64>(0xBFC7D68FB4143000),\n  reinterpret<f64>(0x3FF32F5CCEFFCB24), reinterpret<f64>(0xBFC73CB83C627000),\n  reinterpret<f64>(0x3FF3187775A10D49), reinterpret<f64>(0xBFC6A39A9B376000),\n  reinterpret<f64>(0x3FF301C8373E3990), reinterpret<f64>(0xBFC60B3154B7A000),\n  reinterpret<f64>(0x3FF2EB4EBB95F841), reinterpret<f64>(0xBFC5737D76243000),\n  reinterpret<f64>(0x3FF2D50A0219A9D1), reinterpret<f64>(0xBFC4DC7B8FC23000),\n  reinterpret<f64>(0x3FF2BEF9A8B7FD2A), reinterpret<f64>(0xBFC4462C51D20000),\n  reinterpret<f64>(0x3FF2A91C7A0C1BAB), reinterpret<f64>(0xBFC3B08ABC830000),\n  reinterpret<f64>(0x3FF293726014B530), reinterpret<f64>(0xBFC31B996B490000),\n  reinterpret<f64>(0x3FF27DFA5757A1F5), reinterpret<f64>(0xBFC2875490A44000),\n  reinterpret<f64>(0x3FF268B39B1D3BBF), reinterpret<f64>(0xBFC1F3B9F879A000),\n  reinterpret<f64>(0x3FF2539D838FF5BD), reinterpret<f64>(0xBFC160C8252CA000),\n  reinterpret<f64>(0x3FF23EB7AAC9083B), reinterpret<f64>(0xBFC0CE7F57F72000),\n  reinterpret<f64>(0x3FF22A012BA940B6), reinterpret<f64>(0xBFC03CDC49FEA000),\n  reinterpret<f64>(0x3FF2157996CC4132), reinterpret<f64>(0xBFBF57BDBC4B8000),\n  reinterpret<f64>(0x3FF201201DD2FC9B), reinterpret<f64>(0xBFBE370896404000),\n  reinterpret<f64>(0x3FF1ECF4494D480B), reinterpret<f64>(0xBFBD17983EF94000),\n  reinterpret<f64>(0x3FF1D8F5528F6569), reinterpret<f64>(0xBFBBF9674ED8A000),\n  reinterpret<f64>(0x3FF1C52311577E7C), reinterpret<f64>(0xBFBADC79202F6000),\n  reinterpret<f64>(0x3FF1B17C74CB26E9), reinterpret<f64>(0xBFB9C0C3E7288000),\n  reinterpret<f64>(0x3FF19E010C2C1AB6), reinterpret<f64>(0xBFB8A646B372C000),\n  reinterpret<f64>(0x3FF18AB07BB670BD), reinterpret<f64>(0xBFB78D01B3AC0000),\n  reinterpret<f64>(0x3FF1778A25EFBCB6), reinterpret<f64>(0xBFB674F145380000),\n  reinterpret<f64>(0x3FF1648D354C31DA), reinterpret<f64>(0xBFB55E0E6D878000),\n  reinterpret<f64>(0x3FF151B990275FDD), reinterpret<f64>(0xBFB4485CDEA1E000),\n  reinterpret<f64>(0x3FF13F0EA432D24C), reinterpret<f64>(0xBFB333D94D6AA000),\n  reinterpret<f64>(0x3FF12C8B7210F9DA), reinterpret<f64>(0xBFB22079F8C56000),\n  reinterpret<f64>(0x3FF11A3028ECB531), reinterpret<f64>(0xBFB10E4698622000),\n  reinterpret<f64>(0x3FF107FBDA8434AF), reinterpret<f64>(0xBFAFFA6C6AD20000),\n  reinterpret<f64>(0x3FF0F5EE0F4E6BB3), reinterpret<f64>(0xBFADDA8D4A774000),\n  reinterpret<f64>(0x3FF0E4065D2A9FCE), reinterpret<f64>(0xBFABBCECE4850000),\n  reinterpret<f64>(0x3FF0D244632CA521), reinterpret<f64>(0xBFA9A1894012C000),\n  reinterpret<f64>(0x3FF0C0A77CE2981A), reinterpret<f64>(0xBFA788583302C000),\n  reinterpret<f64>(0x3FF0AF2F83C636D1), reinterpret<f64>(0xBFA5715E67D68000),\n  reinterpret<f64>(0x3FF09DDB98A01339), reinterpret<f64>(0xBFA35C8A49658000),\n  reinterpret<f64>(0x3FF08CABAF52E7DF), reinterpret<f64>(0xBFA149E364154000),\n  reinterpret<f64>(0x3FF07B9F2F4E28FB), reinterpret<f64>(0xBF9E72C082EB8000),\n  reinterpret<f64>(0x3FF06AB58C358F19), reinterpret<f64>(0xBF9A55F152528000),\n  reinterpret<f64>(0x3FF059EEA5ECF92C), reinterpret<f64>(0xBF963D62CF818000),\n  reinterpret<f64>(0x3FF04949CDD12C90), reinterpret<f64>(0xBF9228FB8CAA0000),\n  reinterpret<f64>(0x3FF038C6C6F0ADA9), reinterpret<f64>(0xBF8C317B20F90000),\n  reinterpret<f64>(0x3FF02865137932A9), reinterpret<f64>(0xBF8419355DAA0000),\n  reinterpret<f64>(0x3FF0182427EA7348), reinterpret<f64>(0xBF781203C2EC0000),\n  reinterpret<f64>(0x3FF008040614B195), reinterpret<f64>(0xBF60040979240000),\n  reinterpret<f64>(0x3FEFE01FF726FA1A), reinterpret<f64>(0x3F6FEFF384900000),\n  reinterpret<f64>(0x3FEFA11CC261EA74), reinterpret<f64>(0x3F87DC41353D0000),\n  reinterpret<f64>(0x3FEF6310B081992E), reinterpret<f64>(0x3F93CEA3C4C28000),\n  reinterpret<f64>(0x3FEF25F63CEEADCD), reinterpret<f64>(0x3F9B9FC114890000),\n  reinterpret<f64>(0x3FEEE9C8039113E7), reinterpret<f64>(0x3FA1B0D8CE110000),\n  reinterpret<f64>(0x3FEEAE8078CBB1AB), reinterpret<f64>(0x3FA58A5BD001C000),\n  reinterpret<f64>(0x3FEE741AA29D0C9B), reinterpret<f64>(0x3FA95C8340D88000),\n  reinterpret<f64>(0x3FEE3A91830A99B5), reinterpret<f64>(0x3FAD276AEF578000),\n  reinterpret<f64>(0x3FEE01E009609A56), reinterpret<f64>(0x3FB07598E598C000),\n  reinterpret<f64>(0x3FEDCA01E577BB98), reinterpret<f64>(0x3FB253F5E30D2000),\n  reinterpret<f64>(0x3FED92F20B7C9103), reinterpret<f64>(0x3FB42EDD8B380000),\n  reinterpret<f64>(0x3FED5CAC66FB5CCE), reinterpret<f64>(0x3FB606598757C000),\n  reinterpret<f64>(0x3FED272CAA5EDE9D), reinterpret<f64>(0x3FB7DA76356A0000),\n  reinterpret<f64>(0x3FECF26E3E6B2CCD), reinterpret<f64>(0x3FB9AB434E1C6000),\n  reinterpret<f64>(0x3FECBE6DA2A77902), reinterpret<f64>(0x3FBB78C7BB0D6000),\n  reinterpret<f64>(0x3FEC8B266D37086D), reinterpret<f64>(0x3FBD431332E72000),\n  reinterpret<f64>(0x3FEC5894BD5D5804), reinterpret<f64>(0x3FBF0A3171DE6000),\n  reinterpret<f64>(0x3FEC26B533BB9F8C), reinterpret<f64>(0x3FC067152B914000),\n  reinterpret<f64>(0x3FEBF583EEECE73F), reinterpret<f64>(0x3FC147858292B000),\n  reinterpret<f64>(0x3FEBC4FD75DB96C1), reinterpret<f64>(0x3FC2266ECDCA3000),\n  reinterpret<f64>(0x3FEB951E0C864A28), reinterpret<f64>(0x3FC303D7A6C55000),\n  reinterpret<f64>(0x3FEB65E2C5EF3E2C), reinterpret<f64>(0x3FC3DFC33C331000),\n  reinterpret<f64>(0x3FEB374867C9888B), reinterpret<f64>(0x3FC4BA366B7A8000),\n  reinterpret<f64>(0x3FEB094B211D304A), reinterpret<f64>(0x3FC5933928D1F000),\n  reinterpret<f64>(0x3FEADBE885F2EF7E), reinterpret<f64>(0x3FC66ACD2418F000),\n  reinterpret<f64>(0x3FEAAF1D31603DA2), reinterpret<f64>(0x3FC740F8EC669000),\n  reinterpret<f64>(0x3FEA82E63FD358A7), reinterpret<f64>(0x3FC815C0F51AF000),\n  reinterpret<f64>(0x3FEA5740EF09738B), reinterpret<f64>(0x3FC8E92954F68000),\n  reinterpret<f64>(0x3FEA2C2A90AB4B27), reinterpret<f64>(0x3FC9BB3602F84000),\n  reinterpret<f64>(0x3FEA01A01393F2D1), reinterpret<f64>(0x3FCA8BED1C2C0000),\n  reinterpret<f64>(0x3FE9D79F24DB3C1B), reinterpret<f64>(0x3FCB5B515C01D000),\n  reinterpret<f64>(0x3FE9AE2505C7B190), reinterpret<f64>(0x3FCC2967CCBCC000),\n  reinterpret<f64>(0x3FE9852EF297CE2F), reinterpret<f64>(0x3FCCF635D5486000),\n  reinterpret<f64>(0x3FE95CBAEEA44B75), reinterpret<f64>(0x3FCDC1BD3446C000),\n  reinterpret<f64>(0x3FE934C69DE74838), reinterpret<f64>(0x3FCE8C01B8CFE000),\n  reinterpret<f64>(0x3FE90D4F2F6752E6), reinterpret<f64>(0x3FCF5509C0179000),\n  reinterpret<f64>(0x3FE8E6528EFFD79D), reinterpret<f64>(0x3FD00E6C121FB800),\n  reinterpret<f64>(0x3FE8BFCE9FCC007C), reinterpret<f64>(0x3FD071B80E93D000),\n  reinterpret<f64>(0x3FE899C0DABEC30E), reinterpret<f64>(0x3FD0D46B9E867000),\n  reinterpret<f64>(0x3FE87427AA2317FB), reinterpret<f64>(0x3FD13687334BD000),\n  reinterpret<f64>(0x3FE84F00ACB39A08), reinterpret<f64>(0x3FD1980D67234800),\n  reinterpret<f64>(0x3FE82A49E8653E55), reinterpret<f64>(0x3FD1F8FFE0CC8000),\n  reinterpret<f64>(0x3FE8060195F40260), reinterpret<f64>(0x3FD2595FD7636800),\n  reinterpret<f64>(0x3FE7E22563E0A329), reinterpret<f64>(0x3FD2B9300914A800),\n  reinterpret<f64>(0x3FE7BEB377DCB5AD), reinterpret<f64>(0x3FD3187210436000),\n  reinterpret<f64>(0x3FE79BAA679725C2), reinterpret<f64>(0x3FD377266DEC1800),\n  reinterpret<f64>(0x3FE77907F2170657), reinterpret<f64>(0x3FD3D54FFBAF3000),\n  reinterpret<f64>(0x3FE756CADBD6130C), reinterpret<f64>(0x3FD432EEE32FE000)\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data<f64>([\n  //               chi                ,                  clo\n  reinterpret<f64>(0x3FE61000014FB66B), reinterpret<f64>(0x3C7E026C91425B3C),\n  reinterpret<f64>(0x3FE63000034DB495), reinterpret<f64>(0x3C8DBFEA48005D41),\n  reinterpret<f64>(0x3FE650000D94D478), reinterpret<f64>(0x3C8E7FA786D6A5B7),\n  reinterpret<f64>(0x3FE67000074E6FAD), reinterpret<f64>(0x3C61FCEA6B54254C),\n  reinterpret<f64>(0x3FE68FFFFEDF0FAE), reinterpret<f64>(0xBC7C7E274C590EFD),\n  reinterpret<f64>(0x3FE6B0000763C5BC), reinterpret<f64>(0xBC8AC16848DCDA01),\n  reinterpret<f64>(0x3FE6D0001E5CC1F6), reinterpret<f64>(0x3C833F1C9D499311),\n  reinterpret<f64>(0x3FE6EFFFEB05F63E), reinterpret<f64>(0xBC7E80041AE22D53),\n  reinterpret<f64>(0x3FE710000E869780), reinterpret<f64>(0x3C7BFF6671097952),\n  reinterpret<f64>(0x3FE72FFFFC67E912), reinterpret<f64>(0x3C8C00E226BD8724),\n  reinterpret<f64>(0x3FE74FFFDF81116A), reinterpret<f64>(0xBC6E02916EF101D2),\n  reinterpret<f64>(0x3FE770000F679C90), reinterpret<f64>(0xBC67FC71CD549C74),\n  reinterpret<f64>(0x3FE78FFFFA7EC835), reinterpret<f64>(0x3C81BEC19EF50483),\n  reinterpret<f64>(0x3FE7AFFFFE20C2E6), reinterpret<f64>(0xBC707E1729CC6465),\n  reinterpret<f64>(0x3FE7CFFFED3FC900), reinterpret<f64>(0xBC808072087B8B1C),\n  reinterpret<f64>(0x3FE7EFFFE9261A76), reinterpret<f64>(0x3C8DC0286D9DF9AE),\n  reinterpret<f64>(0x3FE81000049CA3E8), reinterpret<f64>(0x3C897FD251E54C33),\n  reinterpret<f64>(0x3FE8300017932C8F), reinterpret<f64>(0xBC8AFEE9B630F381),\n  reinterpret<f64>(0x3FE850000633739C), reinterpret<f64>(0x3C89BFBF6B6535BC),\n  reinterpret<f64>(0x3FE87000204289C6), reinterpret<f64>(0xBC8BBF65F3117B75),\n  reinterpret<f64>(0x3FE88FFFEBF57904), reinterpret<f64>(0xBC89006EA23DCB57),\n  reinterpret<f64>(0x3FE8B00022BC04DF), reinterpret<f64>(0xBC7D00DF38E04B0A),\n  reinterpret<f64>(0x3FE8CFFFE50C1B8A), reinterpret<f64>(0xBC88007146FF9F05),\n  reinterpret<f64>(0x3FE8EFFFFC918E43), reinterpret<f64>(0x3C83817BD07A7038),\n  reinterpret<f64>(0x3FE910001EFA5FC7), reinterpret<f64>(0x3C893E9176DFB403),\n  reinterpret<f64>(0x3FE9300013467BB9), reinterpret<f64>(0x3C7F804E4B980276),\n  reinterpret<f64>(0x3FE94FFFE6EE076F), reinterpret<f64>(0xBC8F7EF0D9FF622E),\n  reinterpret<f64>(0x3FE96FFFDE3C12D1), reinterpret<f64>(0xBC7082AA962638BA),\n  reinterpret<f64>(0x3FE98FFFF4458A0D), reinterpret<f64>(0xBC87801B9164A8EF),\n  reinterpret<f64>(0x3FE9AFFFDD982E3E), reinterpret<f64>(0xBC8740E08A5A9337),\n  reinterpret<f64>(0x3FE9CFFFED49FB66), reinterpret<f64>(0x3C3FCE08C19BE000),\n  reinterpret<f64>(0x3FE9F00020F19C51), reinterpret<f64>(0xBC8A3FAA27885B0A),\n  reinterpret<f64>(0x3FEA10001145B006), reinterpret<f64>(0x3C74FF489958DA56),\n  reinterpret<f64>(0x3FEA300007BBF6FA), reinterpret<f64>(0x3C8CBEAB8A2B6D18),\n  reinterpret<f64>(0x3FEA500010971D79), reinterpret<f64>(0x3C88FECADD787930),\n  reinterpret<f64>(0x3FEA70001DF52E48), reinterpret<f64>(0xBC8F41763DD8ABDB),\n  reinterpret<f64>(0x3FEA90001C593352), reinterpret<f64>(0xBC8EBF0284C27612),\n  reinterpret<f64>(0x3FEAB0002A4F3E4B), reinterpret<f64>(0xBC69FD043CFF3F5F),\n  reinterpret<f64>(0x3FEACFFFD7AE1ED1), reinterpret<f64>(0xBC823EE7129070B4),\n  reinterpret<f64>(0x3FEAEFFFEE510478), reinterpret<f64>(0x3C6A063EE00EDEA3),\n  reinterpret<f64>(0x3FEB0FFFDB650D5B), reinterpret<f64>(0x3C5A06C8381F0AB9),\n  reinterpret<f64>(0x3FEB2FFFFEAACA57), reinterpret<f64>(0xBC79011E74233C1D),\n  reinterpret<f64>(0x3FEB4FFFD995BADC), reinterpret<f64>(0xBC79FF1068862A9F),\n  reinterpret<f64>(0x3FEB7000249E659C), reinterpret<f64>(0x3C8AFF45D0864F3E),\n  reinterpret<f64>(0x3FEB8FFFF9871640), reinterpret<f64>(0x3C7CFE7796C2C3F9),\n  reinterpret<f64>(0x3FEBAFFFD204CB4F), reinterpret<f64>(0xBC63FF27EEF22BC4),\n  reinterpret<f64>(0x3FEBCFFFD2415C45), reinterpret<f64>(0xBC6CFFB7EE3BEA21),\n  reinterpret<f64>(0x3FEBEFFFF86309DF), reinterpret<f64>(0xBC814103972E0B5C),\n  reinterpret<f64>(0x3FEC0FFFE1B57653), reinterpret<f64>(0x3C8BC16494B76A19),\n  reinterpret<f64>(0x3FEC2FFFF1FA57E3), reinterpret<f64>(0xBC64FEEF8D30C6ED),\n  reinterpret<f64>(0x3FEC4FFFDCBFE424), reinterpret<f64>(0xBC843F68BCEC4775),\n  reinterpret<f64>(0x3FEC6FFFED54B9F7), reinterpret<f64>(0x3C847EA3F053E0EC),\n  reinterpret<f64>(0x3FEC8FFFEB998FD5), reinterpret<f64>(0x3C7383068DF992F1),\n  reinterpret<f64>(0x3FECB0002125219A), reinterpret<f64>(0xBC68FD8E64180E04),\n  reinterpret<f64>(0x3FECCFFFDD94469C), reinterpret<f64>(0x3C8E7EBE1CC7EA72),\n  reinterpret<f64>(0x3FECEFFFEAFDC476), reinterpret<f64>(0x3C8EBE39AD9F88FE),\n  reinterpret<f64>(0x3FED1000169AF82B), reinterpret<f64>(0x3C757D91A8B95A71),\n  reinterpret<f64>(0x3FED30000D0FF71D), reinterpret<f64>(0x3C89C1906970C7DA),\n  reinterpret<f64>(0x3FED4FFFEA790FC4), reinterpret<f64>(0xBC580E37C558FE0C),\n  reinterpret<f64>(0x3FED70002EDC87E5), reinterpret<f64>(0xBC7F80D64DC10F44),\n  reinterpret<f64>(0x3FED900021DC82AA), reinterpret<f64>(0xBC747C8F94FD5C5C),\n  reinterpret<f64>(0x3FEDAFFFD86B0283), reinterpret<f64>(0x3C8C7F1DC521617E),\n  reinterpret<f64>(0x3FEDD000296C4739), reinterpret<f64>(0x3C88019EB2FFB153),\n  reinterpret<f64>(0x3FEDEFFFE54490F5), reinterpret<f64>(0x3C6E00D2C652CC89),\n  reinterpret<f64>(0x3FEE0FFFCDABF694), reinterpret<f64>(0xBC7F8340202D69D2),\n  reinterpret<f64>(0x3FEE2FFFDB52C8DD), reinterpret<f64>(0x3C7B00C1CA1B0864),\n  reinterpret<f64>(0x3FEE4FFFF24216EF), reinterpret<f64>(0x3C72FFA8B094AB51),\n  reinterpret<f64>(0x3FEE6FFFE88A5E11), reinterpret<f64>(0xBC57F673B1EFBE59),\n  reinterpret<f64>(0x3FEE9000119EFF0D), reinterpret<f64>(0xBC84808D5E0BC801),\n  reinterpret<f64>(0x3FEEAFFFDFA51744), reinterpret<f64>(0x3C780006D54320B5),\n  reinterpret<f64>(0x3FEED0001A127FA1), reinterpret<f64>(0xBC5002F860565C92),\n  reinterpret<f64>(0x3FEEF00007BABCC4), reinterpret<f64>(0xBC8540445D35E611),\n  reinterpret<f64>(0x3FEF0FFFF57A8D02), reinterpret<f64>(0xBC4FFB3139EF9105),\n  reinterpret<f64>(0x3FEF30001EE58AC7), reinterpret<f64>(0x3C8A81ACF2731155),\n  reinterpret<f64>(0x3FEF4FFFF5823494), reinterpret<f64>(0x3C8A3F41D4D7C743),\n  reinterpret<f64>(0x3FEF6FFFFCA94C6B), reinterpret<f64>(0xBC6202F41C987875),\n  reinterpret<f64>(0x3FEF8FFFE1F9C441), reinterpret<f64>(0x3C777DD1F477E74B),\n  reinterpret<f64>(0x3FEFAFFFD2E0E37E), reinterpret<f64>(0xBC6F01199A7CA331),\n  reinterpret<f64>(0x3FEFD0001C77E49E), reinterpret<f64>(0x3C7181EE4BCEACB1),\n  reinterpret<f64>(0x3FEFEFFFF7E0C331), reinterpret<f64>(0xBC6E05370170875A),\n  reinterpret<f64>(0x3FF00FFFF465606E), reinterpret<f64>(0xBC8A7EAD491C0ADA),\n  reinterpret<f64>(0x3FF02FFFF3867A58), reinterpret<f64>(0xBC977F69C3FCB2E0),\n  reinterpret<f64>(0x3FF04FFFFDFC0D17), reinterpret<f64>(0x3C97BFFE34CB945B),\n  reinterpret<f64>(0x3FF0700003CD4D82), reinterpret<f64>(0x3C820083C0E456CB),\n  reinterpret<f64>(0x3FF08FFFF9F2CBE8), reinterpret<f64>(0xBC6DFFDFBE37751A),\n  reinterpret<f64>(0x3FF0B000010CDA65), reinterpret<f64>(0xBC913F7FAEE626EB),\n  reinterpret<f64>(0x3FF0D00001A4D338), reinterpret<f64>(0x3C807DFA79489FF7),\n  reinterpret<f64>(0x3FF0EFFFFADAFDFD), reinterpret<f64>(0xBC77040570D66BC0),\n  reinterpret<f64>(0x3FF110000BBAFD96), reinterpret<f64>(0x3C8E80D4846D0B62),\n  reinterpret<f64>(0x3FF12FFFFAE5F45D), reinterpret<f64>(0x3C9DBFFA64FD36EF),\n  reinterpret<f64>(0x3FF150000DD59AD9), reinterpret<f64>(0x3C9A0077701250AE),\n  reinterpret<f64>(0x3FF170000F21559A), reinterpret<f64>(0x3C8DFDF9E2E3DEEE),\n  reinterpret<f64>(0x3FF18FFFFC275426), reinterpret<f64>(0x3C910030DC3B7273),\n  reinterpret<f64>(0x3FF1B000123D3C59), reinterpret<f64>(0x3C997F7980030188),\n  reinterpret<f64>(0x3FF1CFFFF8299EB7), reinterpret<f64>(0xBC65F932AB9F8C67),\n  reinterpret<f64>(0x3FF1EFFFF48AD400), reinterpret<f64>(0x3C937FBF9DA75BEB),\n  reinterpret<f64>(0x3FF210000C8B86A4), reinterpret<f64>(0x3C9F806B91FD5B22),\n  reinterpret<f64>(0x3FF2300003854303), reinterpret<f64>(0x3C93FFC2EB9FBF33),\n  reinterpret<f64>(0x3FF24FFFFFBCF684), reinterpret<f64>(0x3C7601E77E2E2E72),\n  reinterpret<f64>(0x3FF26FFFF52921D9), reinterpret<f64>(0x3C7FFCBB767F0C61),\n  reinterpret<f64>(0x3FF2900014933A3C), reinterpret<f64>(0xBC7202CA3C02412B),\n  reinterpret<f64>(0x3FF2B00014556313), reinterpret<f64>(0xBC92808233F21F02),\n  reinterpret<f64>(0x3FF2CFFFEBFE523B), reinterpret<f64>(0xBC88FF7E384FDCF2),\n  reinterpret<f64>(0x3FF2F0000BB8AD96), reinterpret<f64>(0xBC85FF51503041C5),\n  reinterpret<f64>(0x3FF30FFFFB7AE2AF), reinterpret<f64>(0xBC810071885E289D),\n  reinterpret<f64>(0x3FF32FFFFEAC5F7F), reinterpret<f64>(0xBC91FF5D3FB7B715),\n  reinterpret<f64>(0x3FF350000CA66756), reinterpret<f64>(0x3C957F82228B82BD),\n  reinterpret<f64>(0x3FF3700011FBF721), reinterpret<f64>(0x3C8000BAC40DD5CC),\n  reinterpret<f64>(0x3FF38FFFF9592FB9), reinterpret<f64>(0xBC943F9D2DB2A751),\n  reinterpret<f64>(0x3FF3B00004DDD242), reinterpret<f64>(0x3C857F6B707638E1),\n  reinterpret<f64>(0x3FF3CFFFF5B2C957), reinterpret<f64>(0x3C7A023A10BF1231),\n  reinterpret<f64>(0x3FF3EFFFEAB0B418), reinterpret<f64>(0x3C987F6D66B152B0),\n  reinterpret<f64>(0x3FF410001532AFF4), reinterpret<f64>(0x3C67F8375F198524),\n  reinterpret<f64>(0x3FF4300017478B29), reinterpret<f64>(0x3C8301E672DC5143),\n  reinterpret<f64>(0x3FF44FFFE795B463), reinterpret<f64>(0x3C89FF69B8B2895A),\n  reinterpret<f64>(0x3FF46FFFE80475E0), reinterpret<f64>(0xBC95C0B19BC2F254),\n  reinterpret<f64>(0x3FF48FFFEF6FC1E7), reinterpret<f64>(0x3C9B4009F23A2A72),\n  reinterpret<f64>(0x3FF4AFFFE5BEA704), reinterpret<f64>(0xBC94FFB7BF0D7D45),\n  reinterpret<f64>(0x3FF4D000171027DE), reinterpret<f64>(0xBC99C06471DC6A3D),\n  reinterpret<f64>(0x3FF4F0000FF03EE2), reinterpret<f64>(0x3C977F890B85531C),\n  reinterpret<f64>(0x3FF5100012DC4BD1), reinterpret<f64>(0x3C6004657166A436),\n  reinterpret<f64>(0x3FF530001605277A), reinterpret<f64>(0xBC96BFCECE233209),\n  reinterpret<f64>(0x3FF54FFFECDB704C), reinterpret<f64>(0xBC8902720505A1D7),\n  reinterpret<f64>(0x3FF56FFFEF5F54A9), reinterpret<f64>(0x3C9BBFE60EC96412),\n  reinterpret<f64>(0x3FF5900017E61012), reinterpret<f64>(0x3C887EC581AFEF90),\n  reinterpret<f64>(0x3FF5B00003C93E92), reinterpret<f64>(0xBC9F41080ABF0CC0),\n  reinterpret<f64>(0x3FF5D0001D4919BC), reinterpret<f64>(0xBC98812AFB254729),\n  reinterpret<f64>(0x3FF5EFFFE7B87A89), reinterpret<f64>(0xBC947EB780ED6904)\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n  const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n  const\n    B0  = reinterpret<f64>(0xBFE0000000000000), // -0x1p-1\n    B1  = reinterpret<f64>(0x3FD5555555555577), //  0x1.5555555555577p-2\n    B2  = reinterpret<f64>(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n    B3  = reinterpret<f64>(0x3FC999999995DD0C), //  0x1.999999995dd0cp-3\n    B4  = reinterpret<f64>(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n    B5  = reinterpret<f64>(0x3FC24924A344DE30), //  0x1.24924a344de3p-3\n    B6  = reinterpret<f64>(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n    B7  = reinterpret<f64>(0x3FBC7184282AD6CA), //  0x1.c7184282ad6cap-4\n    B8  = reinterpret<f64>(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n    B9  = reinterpret<f64>(0x3FB78182F7AFD085), //  0x1.78182f7afd085p-4\n    B10 = reinterpret<f64>(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n  const\n    A0 = reinterpret<f64>(0xBFE0000000000001),  // -0x1.0000000000001p-1\n    A1 = reinterpret<f64>(0x3FD555555551305B),  //  0x1.555555551305bp-2\n    A2 = reinterpret<f64>(0xBFCFFFFFFFEB4590),  // -0x1.fffffffeb459p-3\n    A3 = reinterpret<f64>(0x3FC999B324F10111),  //  0x1.999b324f10111p-3\n    A4 = reinterpret<f64>(0xBFC55575E506C89F);  // -0x1.55575e506c89fp-3\n\n  const\n    LO: u64 = 0x3FEE000000000000,\n    HI: u64 = 0x3FF1090000000000;\n\n  const\n    Ln2hi  = reinterpret<f64>(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n    Ln2lo  = reinterpret<f64>(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n    Ox1p27 = reinterpret<f64>(0x41A0000000000000), // 0x1p27\n    Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  var ix = reinterpret<u64>(x);\n  if (ix - LO < HI - LO) {\n    let r  = x - 1.0;\n    let r2 = r * r;\n    let r3 = r2 * r;\n    let y =\n      r3 * (B1 + r * B2 + r2 * B3 +\n      r3 * (B4 + r * B5 + r2 * B6 +\n      r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n    // Worst-case error is around 0.507 ULP\n    let w   = r * Ox1p27;\n    let rhi = r + w - w;\n    let rlo = r - rhi;\n    w = rhi * rhi * B0; // B[0] == -0.5\n    let hi = r + w;\n    let lo = r - hi + w;\n    lo += B0 * rlo * (rhi + r);\n    return y + lo + hi;\n  }\n  var top = u32(ix >> 48);\n  if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n    // x < 0x1p-1022 or inf or nan\n    if ((ix << 1) == 0) return -1.0 / (x * x);\n    if (ix == reinterpret<u64>(Infinity)) return x; // log(inf) == inf\n    if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n    // x is subnormal, normalize it\n    ix = reinterpret<u64>(x * Ox1p52);\n    ix -= u64(52) << 52;\n  }\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp  = ix - 0x3FE6000000000000;\n  var i    = <usize>((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n  var k    = <i64>tmp >> 52;\n  var iz   = ix - (tmp & (u64(0xFFF) << 52));\n\n  var invc = load<f64>(LOG_DATA_TAB1 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].invc;\n  var logc = load<f64>(LOG_DATA_TAB1 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].logc;\n  var z    = reinterpret<f64>(iz);\n\n  // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n  // r ~= z/c - 1, |r| < 1/(2*N)\n  // #if __FP_FAST_FMA\n  // \t// rounding error: 0x1p-55/N\n  // \tr = __builtin_fma(z, invc, -1.0);\n  // #else\n  // rounding error: 0x1p-55/N + 0x1p-66\n  const chi = load<f64>(LOG_DATA_TAB2 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T2[i].chi\n  const clo = load<f64>(LOG_DATA_TAB2 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T2[i].clo\n  var r = (z - chi - clo) * invc;\n  // #endif\n  var kd = <f64>k;\n\n  // hi + lo = r + log(c) + k*Ln2\n  var w  = kd * Ln2hi + logc;\n  var hi = w + r;\n  var lo = w - hi + r + kd * Ln2lo;\n\n  // log(x) = lo + (log1p(r) - r) + hi\n  var r2 = r * r; // rounding error: 0x1p-54/N^2\n  // Worst case error if |y| > 0x1p-5:\n  // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n  // Worst case error if |y| > 0x1p-4:\n  // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n  return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n  x = 2^k z\n  log(x) = k ln2 + log(c) + log(z/c)\n  log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = round(0x1p43*log(c))/0x1p43\n  tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n  1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data<f64>([\n  //             invc                 ,pad,               logc                 ,               logctail\n  reinterpret<f64>(0x3FF6A00000000000), 0, reinterpret<f64>(0xBFD62C82F2B9C800), reinterpret<f64>(0x3CFAB42428375680),\n  reinterpret<f64>(0x3FF6800000000000), 0, reinterpret<f64>(0xBFD5D1BDBF580800), reinterpret<f64>(0xBD1CA508D8E0F720),\n  reinterpret<f64>(0x3FF6600000000000), 0, reinterpret<f64>(0xBFD5767717455800), reinterpret<f64>(0xBD2362A4D5B6506D),\n  reinterpret<f64>(0x3FF6400000000000), 0, reinterpret<f64>(0xBFD51AAD872DF800), reinterpret<f64>(0xBCE684E49EB067D5),\n  reinterpret<f64>(0x3FF6200000000000), 0, reinterpret<f64>(0xBFD4BE5F95777800), reinterpret<f64>(0xBD041B6993293EE0),\n  reinterpret<f64>(0x3FF6000000000000), 0, reinterpret<f64>(0xBFD4618BC21C6000), reinterpret<f64>(0x3D13D82F484C84CC),\n  reinterpret<f64>(0x3FF5E00000000000), 0, reinterpret<f64>(0xBFD404308686A800), reinterpret<f64>(0x3CDC42F3ED820B3A),\n  reinterpret<f64>(0x3FF5C00000000000), 0, reinterpret<f64>(0xBFD3A64C55694800), reinterpret<f64>(0x3D20B1C686519460),\n  reinterpret<f64>(0x3FF5A00000000000), 0, reinterpret<f64>(0xBFD347DD9A988000), reinterpret<f64>(0x3D25594DD4C58092),\n  reinterpret<f64>(0x3FF5800000000000), 0, reinterpret<f64>(0xBFD2E8E2BAE12000), reinterpret<f64>(0x3D267B1E99B72BD8),\n  reinterpret<f64>(0x3FF5600000000000), 0, reinterpret<f64>(0xBFD2895A13DE8800), reinterpret<f64>(0x3D15CA14B6CFB03F),\n  reinterpret<f64>(0x3FF5600000000000), 0, reinterpret<f64>(0xBFD2895A13DE8800), reinterpret<f64>(0x3D15CA14B6CFB03F),\n  reinterpret<f64>(0x3FF5400000000000), 0, reinterpret<f64>(0xBFD22941FBCF7800), reinterpret<f64>(0xBD165A242853DA76),\n  reinterpret<f64>(0x3FF5200000000000), 0, reinterpret<f64>(0xBFD1C898C1699800), reinterpret<f64>(0xBD1FAFBC68E75404),\n  reinterpret<f64>(0x3FF5000000000000), 0, reinterpret<f64>(0xBFD1675CABABA800), reinterpret<f64>(0x3D1F1FC63382A8F0),\n  reinterpret<f64>(0x3FF4E00000000000), 0, reinterpret<f64>(0xBFD1058BF9AE4800), reinterpret<f64>(0xBD26A8C4FD055A66),\n  reinterpret<f64>(0x3FF4C00000000000), 0, reinterpret<f64>(0xBFD0A324E2739000), reinterpret<f64>(0xBD0C6BEE7EF4030E),\n  reinterpret<f64>(0x3FF4A00000000000), 0, reinterpret<f64>(0xBFD0402594B4D000), reinterpret<f64>(0xBCF036B89EF42D7F),\n  reinterpret<f64>(0x3FF4A00000000000), 0, reinterpret<f64>(0xBFD0402594B4D000), reinterpret<f64>(0xBCF036B89EF42D7F),\n  reinterpret<f64>(0x3FF4800000000000), 0, reinterpret<f64>(0xBFCFB9186D5E4000), reinterpret<f64>(0x3D0D572AAB993C87),\n  reinterpret<f64>(0x3FF4600000000000), 0, reinterpret<f64>(0xBFCEF0ADCBDC6000), reinterpret<f64>(0x3D2B26B79C86AF24),\n  reinterpret<f64>(0x3FF4400000000000), 0, reinterpret<f64>(0xBFCE27076E2AF000), reinterpret<f64>(0xBD172F4F543FFF10),\n  reinterpret<f64>(0x3FF4200000000000), 0, reinterpret<f64>(0xBFCD5C216B4FC000), reinterpret<f64>(0x3D21BA91BBCA681B),\n  reinterpret<f64>(0x3FF4000000000000), 0, reinterpret<f64>(0xBFCC8FF7C79AA000), reinterpret<f64>(0x3D27794F689F8434),\n  reinterpret<f64>(0x3FF4000000000000), 0, reinterpret<f64>(0xBFCC8FF7C79AA000), reinterpret<f64>(0x3D27794F689F8434),\n  reinterpret<f64>(0x3FF3E00000000000), 0, reinterpret<f64>(0xBFCBC286742D9000), reinterpret<f64>(0x3D194EB0318BB78F),\n  reinterpret<f64>(0x3FF3C00000000000), 0, reinterpret<f64>(0xBFCAF3C94E80C000), reinterpret<f64>(0x3CBA4E633FCD9066),\n  reinterpret<f64>(0x3FF3A00000000000), 0, reinterpret<f64>(0xBFCA23BC1FE2B000), reinterpret<f64>(0xBD258C64DC46C1EA),\n  reinterpret<f64>(0x3FF3A00000000000), 0, reinterpret<f64>(0xBFCA23BC1FE2B000), reinterpret<f64>(0xBD258C64DC46C1EA),\n  reinterpret<f64>(0x3FF3800000000000), 0, reinterpret<f64>(0xBFC9525A9CF45000), reinterpret<f64>(0xBD2AD1D904C1D4E3),\n  reinterpret<f64>(0x3FF3600000000000), 0, reinterpret<f64>(0xBFC87FA06520D000), reinterpret<f64>(0x3D2BBDBF7FDBFA09),\n  reinterpret<f64>(0x3FF3400000000000), 0, reinterpret<f64>(0xBFC7AB890210E000), reinterpret<f64>(0x3D2BDB9072534A58),\n  reinterpret<f64>(0x3FF3400000000000), 0, reinterpret<f64>(0xBFC7AB890210E000), reinterpret<f64>(0x3D2BDB9072534A58),\n  reinterpret<f64>(0x3FF3200000000000), 0, reinterpret<f64>(0xBFC6D60FE719D000), reinterpret<f64>(0xBD10E46AA3B2E266),\n  reinterpret<f64>(0x3FF3000000000000), 0, reinterpret<f64>(0xBFC5FF3070A79000), reinterpret<f64>(0xBD1E9E439F105039),\n  reinterpret<f64>(0x3FF3000000000000), 0, reinterpret<f64>(0xBFC5FF3070A79000), reinterpret<f64>(0xBD1E9E439F105039),\n  reinterpret<f64>(0x3FF2E00000000000), 0, reinterpret<f64>(0xBFC526E5E3A1B000), reinterpret<f64>(0xBD20DE8B90075B8F),\n  reinterpret<f64>(0x3FF2C00000000000), 0, reinterpret<f64>(0xBFC44D2B6CCB8000), reinterpret<f64>(0x3D170CC16135783C),\n  reinterpret<f64>(0x3FF2C00000000000), 0, reinterpret<f64>(0xBFC44D2B6CCB8000), reinterpret<f64>(0x3D170CC16135783C),\n  reinterpret<f64>(0x3FF2A00000000000), 0, reinterpret<f64>(0xBFC371FC201E9000), reinterpret<f64>(0x3CF178864D27543A),\n  reinterpret<f64>(0x3FF2800000000000), 0, reinterpret<f64>(0xBFC29552F81FF000), reinterpret<f64>(0xBD248D301771C408),\n  reinterpret<f64>(0x3FF2600000000000), 0, reinterpret<f64>(0xBFC1B72AD52F6000), reinterpret<f64>(0xBD2E80A41811A396),\n  reinterpret<f64>(0x3FF2600000000000), 0, reinterpret<f64>(0xBFC1B72AD52F6000), reinterpret<f64>(0xBD2E80A41811A396),\n  reinterpret<f64>(0x3FF2400000000000), 0, reinterpret<f64>(0xBFC0D77E7CD09000), reinterpret<f64>(0x3D0A699688E85BF4),\n  reinterpret<f64>(0x3FF2400000000000), 0, reinterpret<f64>(0xBFC0D77E7CD09000), reinterpret<f64>(0x3D0A699688E85BF4),\n  reinterpret<f64>(0x3FF2200000000000), 0, reinterpret<f64>(0xBFBFEC9131DBE000), reinterpret<f64>(0xBD2575545CA333F2),\n  reinterpret<f64>(0x3FF2000000000000), 0, reinterpret<f64>(0xBFBE27076E2B0000), reinterpret<f64>(0x3D2A342C2AF0003C),\n  reinterpret<f64>(0x3FF2000000000000), 0, reinterpret<f64>(0xBFBE27076E2B0000), reinterpret<f64>(0x3D2A342C2AF0003C),\n  reinterpret<f64>(0x3FF1E00000000000), 0, reinterpret<f64>(0xBFBC5E548F5BC000), reinterpret<f64>(0xBD1D0C57585FBE06),\n  reinterpret<f64>(0x3FF1C00000000000), 0, reinterpret<f64>(0xBFBA926D3A4AE000), reinterpret<f64>(0x3D253935E85BAAC8),\n  reinterpret<f64>(0x3FF1C00000000000), 0, reinterpret<f64>(0xBFBA926D3A4AE000), reinterpret<f64>(0x3D253935E85BAAC8),\n  reinterpret<f64>(0x3FF1A00000000000), 0, reinterpret<f64>(0xBFB8C345D631A000), reinterpret<f64>(0x3D137C294D2F5668),\n  reinterpret<f64>(0x3FF1A00000000000), 0, reinterpret<f64>(0xBFB8C345D631A000), reinterpret<f64>(0x3D137C294D2F5668),\n  reinterpret<f64>(0x3FF1800000000000), 0, reinterpret<f64>(0xBFB6F0D28AE56000), reinterpret<f64>(0xBD269737C93373DA),\n  reinterpret<f64>(0x3FF1600000000000), 0, reinterpret<f64>(0xBFB51B073F062000), reinterpret<f64>(0x3D1F025B61C65E57),\n  reinterpret<f64>(0x3FF1600000000000), 0, reinterpret<f64>(0xBFB51B073F062000), reinterpret<f64>(0x3D1F025B61C65E57),\n  reinterpret<f64>(0x3FF1400000000000), 0, reinterpret<f64>(0xBFB341D7961BE000), reinterpret<f64>(0x3D2C5EDACCF913DF),\n  reinterpret<f64>(0x3FF1400000000000), 0, reinterpret<f64>(0xBFB341D7961BE000), reinterpret<f64>(0x3D2C5EDACCF913DF),\n  reinterpret<f64>(0x3FF1200000000000), 0, reinterpret<f64>(0xBFB16536EEA38000), reinterpret<f64>(0x3D147C5E768FA309),\n  reinterpret<f64>(0x3FF1000000000000), 0, reinterpret<f64>(0xBFAF0A30C0118000), reinterpret<f64>(0x3D2D599E83368E91),\n  reinterpret<f64>(0x3FF1000000000000), 0, reinterpret<f64>(0xBFAF0A30C0118000), reinterpret<f64>(0x3D2D599E83368E91),\n  reinterpret<f64>(0x3FF0E00000000000), 0, reinterpret<f64>(0xBFAB42DD71198000), reinterpret<f64>(0x3D1C827AE5D6704C),\n  reinterpret<f64>(0x3FF0E00000000000), 0, reinterpret<f64>(0xBFAB42DD71198000), reinterpret<f64>(0x3D1C827AE5D6704C),\n  reinterpret<f64>(0x3FF0C00000000000), 0, reinterpret<f64>(0xBFA77458F632C000), reinterpret<f64>(0xBD2CFC4634F2A1EE),\n  reinterpret<f64>(0x3FF0C00000000000), 0, reinterpret<f64>(0xBFA77458F632C000), reinterpret<f64>(0xBD2CFC4634F2A1EE),\n  reinterpret<f64>(0x3FF0A00000000000), 0, reinterpret<f64>(0xBFA39E87B9FEC000), reinterpret<f64>(0x3CF502B7F526FEAA),\n  reinterpret<f64>(0x3FF0A00000000000), 0, reinterpret<f64>(0xBFA39E87B9FEC000), reinterpret<f64>(0x3CF502B7F526FEAA),\n  reinterpret<f64>(0x3FF0800000000000), 0, reinterpret<f64>(0xBF9F829B0E780000), reinterpret<f64>(0xBD2980267C7E09E4),\n  reinterpret<f64>(0x3FF0800000000000), 0, reinterpret<f64>(0xBF9F829B0E780000), reinterpret<f64>(0xBD2980267C7E09E4),\n  reinterpret<f64>(0x3FF0600000000000), 0, reinterpret<f64>(0xBF97B91B07D58000), reinterpret<f64>(0xBD288D5493FAA639),\n  reinterpret<f64>(0x3FF0400000000000), 0, reinterpret<f64>(0xBF8FC0A8B0FC0000), reinterpret<f64>(0xBCDF1E7CF6D3A69C),\n  reinterpret<f64>(0x3FF0400000000000), 0, reinterpret<f64>(0xBF8FC0A8B0FC0000), reinterpret<f64>(0xBCDF1E7CF6D3A69C),\n  reinterpret<f64>(0x3FF0200000000000), 0, reinterpret<f64>(0xBF7FE02A6B100000), reinterpret<f64>(0xBD19E23F0DDA40E4),\n  reinterpret<f64>(0x3FF0200000000000), 0, reinterpret<f64>(0xBF7FE02A6B100000), reinterpret<f64>(0xBD19E23F0DDA40E4),\n  reinterpret<f64>(0x3FF0000000000000), 0, 0, 0,\n  reinterpret<f64>(0x3FF0000000000000), 0, 0, 0,\n  reinterpret<f64>(0x3FEFC00000000000), 0, reinterpret<f64>(0x3F80101575890000), reinterpret<f64>(0xBD10C76B999D2BE8),\n  reinterpret<f64>(0x3FEF800000000000), 0, reinterpret<f64>(0x3F90205658938000), reinterpret<f64>(0xBD23DC5B06E2F7D2),\n  reinterpret<f64>(0x3FEF400000000000), 0, reinterpret<f64>(0x3F98492528C90000), reinterpret<f64>(0xBD2AA0BA325A0C34),\n  reinterpret<f64>(0x3FEF000000000000), 0, reinterpret<f64>(0x3FA0415D89E74000), reinterpret<f64>(0x3D0111C05CF1D753),\n  reinterpret<f64>(0x3FEEC00000000000), 0, reinterpret<f64>(0x3FA466AED42E0000), reinterpret<f64>(0xBD2C167375BDFD28),\n  reinterpret<f64>(0x3FEE800000000000), 0, reinterpret<f64>(0x3FA894AA149FC000), reinterpret<f64>(0xBD197995D05A267D),\n  reinterpret<f64>(0x3FEE400000000000), 0, reinterpret<f64>(0x3FACCB73CDDDC000), reinterpret<f64>(0xBD1A68F247D82807),\n  reinterpret<f64>(0x3FEE200000000000), 0, reinterpret<f64>(0x3FAEEA31C006C000), reinterpret<f64>(0xBD0E113E4FC93B7B),\n  reinterpret<f64>(0x3FEDE00000000000), 0, reinterpret<f64>(0x3FB1973BD1466000), reinterpret<f64>(0xBD25325D560D9E9B),\n  reinterpret<f64>(0x3FEDA00000000000), 0, reinterpret<f64>(0x3FB3BDF5A7D1E000), reinterpret<f64>(0x3D2CC85EA5DB4ED7),\n  reinterpret<f64>(0x3FED600000000000), 0, reinterpret<f64>(0x3FB5E95A4D97A000), reinterpret<f64>(0xBD2C69063C5D1D1E),\n  reinterpret<f64>(0x3FED400000000000), 0, reinterpret<f64>(0x3FB700D30AEAC000), reinterpret<f64>(0x3CEC1E8DA99DED32),\n  reinterpret<f64>(0x3FED000000000000), 0, reinterpret<f64>(0x3FB9335E5D594000), reinterpret<f64>(0x3D23115C3ABD47DA),\n  reinterpret<f64>(0x3FECC00000000000), 0, reinterpret<f64>(0x3FBB6AC88DAD6000), reinterpret<f64>(0xBD1390802BF768E5),\n  reinterpret<f64>(0x3FECA00000000000), 0, reinterpret<f64>(0x3FBC885801BC4000), reinterpret<f64>(0x3D2646D1C65AACD3),\n  reinterpret<f64>(0x3FEC600000000000), 0, reinterpret<f64>(0x3FBEC739830A2000), reinterpret<f64>(0xBD2DC068AFE645E0),\n  reinterpret<f64>(0x3FEC400000000000), 0, reinterpret<f64>(0x3FBFE89139DBE000), reinterpret<f64>(0xBD2534D64FA10AFD),\n  reinterpret<f64>(0x3FEC000000000000), 0, reinterpret<f64>(0x3FC1178E8227E000), reinterpret<f64>(0x3D21EF78CE2D07F2),\n  reinterpret<f64>(0x3FEBE00000000000), 0, reinterpret<f64>(0x3FC1AA2B7E23F000), reinterpret<f64>(0x3D2CA78E44389934),\n  reinterpret<f64>(0x3FEBA00000000000), 0, reinterpret<f64>(0x3FC2D1610C868000), reinterpret<f64>(0x3D039D6CCB81B4A1),\n  reinterpret<f64>(0x3FEB800000000000), 0, reinterpret<f64>(0x3FC365FCB0159000), reinterpret<f64>(0x3CC62FA8234B7289),\n  reinterpret<f64>(0x3FEB400000000000), 0, reinterpret<f64>(0x3FC4913D8333B000), reinterpret<f64>(0x3D25837954FDB678),\n  reinterpret<f64>(0x3FEB200000000000), 0, reinterpret<f64>(0x3FC527E5E4A1B000), reinterpret<f64>(0x3D2633E8E5697DC7),\n  reinterpret<f64>(0x3FEAE00000000000), 0, reinterpret<f64>(0x3FC6574EBE8C1000), reinterpret<f64>(0x3D19CF8B2C3C2E78),\n  reinterpret<f64>(0x3FEAC00000000000), 0, reinterpret<f64>(0x3FC6F0128B757000), reinterpret<f64>(0xBD25118DE59C21E1),\n  reinterpret<f64>(0x3FEAA00000000000), 0, reinterpret<f64>(0x3FC7898D85445000), reinterpret<f64>(0xBD1C661070914305),\n  reinterpret<f64>(0x3FEA600000000000), 0, reinterpret<f64>(0x3FC8BEAFEB390000), reinterpret<f64>(0xBD073D54AAE92CD1),\n  reinterpret<f64>(0x3FEA400000000000), 0, reinterpret<f64>(0x3FC95A5ADCF70000), reinterpret<f64>(0x3D07F22858A0FF6F),\n  reinterpret<f64>(0x3FEA000000000000), 0, reinterpret<f64>(0x3FCA93ED3C8AE000), reinterpret<f64>(0xBD28724350562169),\n  reinterpret<f64>(0x3FE9E00000000000), 0, reinterpret<f64>(0x3FCB31D8575BD000), reinterpret<f64>(0xBD0C358D4EACE1AA),\n  reinterpret<f64>(0x3FE9C00000000000), 0, reinterpret<f64>(0x3FCBD087383BE000), reinterpret<f64>(0xBD2D4BC4595412B6),\n  reinterpret<f64>(0x3FE9A00000000000), 0, reinterpret<f64>(0x3FCC6FFBC6F01000), reinterpret<f64>(0xBCF1EC72C5962BD2),\n  reinterpret<f64>(0x3FE9600000000000), 0, reinterpret<f64>(0x3FCDB13DB0D49000), reinterpret<f64>(0xBD2AFF2AF715B035),\n  reinterpret<f64>(0x3FE9400000000000), 0, reinterpret<f64>(0x3FCE530EFFE71000), reinterpret<f64>(0x3CC212276041F430),\n  reinterpret<f64>(0x3FE9200000000000), 0, reinterpret<f64>(0x3FCEF5ADE4DD0000), reinterpret<f64>(0xBCCA211565BB8E11),\n  reinterpret<f64>(0x3FE9000000000000), 0, reinterpret<f64>(0x3FCF991C6CB3B000), reinterpret<f64>(0x3D1BCBECCA0CDF30),\n  reinterpret<f64>(0x3FE8C00000000000), 0, reinterpret<f64>(0x3FD07138604D5800), reinterpret<f64>(0x3CF89CDB16ED4E91),\n  reinterpret<f64>(0x3FE8A00000000000), 0, reinterpret<f64>(0x3FD0C42D67616000), reinterpret<f64>(0x3D27188B163CEAE9),\n  reinterpret<f64>(0x3FE8800000000000), 0, reinterpret<f64>(0x3FD1178E8227E800), reinterpret<f64>(0xBD2C210E63A5F01C),\n  reinterpret<f64>(0x3FE8600000000000), 0, reinterpret<f64>(0x3FD16B5CCBACF800), reinterpret<f64>(0x3D2B9ACDF7A51681),\n  reinterpret<f64>(0x3FE8400000000000), 0, reinterpret<f64>(0x3FD1BF99635A6800), reinterpret<f64>(0x3D2CA6ED5147BDB7),\n  reinterpret<f64>(0x3FE8200000000000), 0, reinterpret<f64>(0x3FD214456D0EB800), reinterpret<f64>(0x3D0A87DEBA46BAEA),\n  reinterpret<f64>(0x3FE7E00000000000), 0, reinterpret<f64>(0x3FD2BEF07CDC9000), reinterpret<f64>(0x3D2A9CFA4A5004F4),\n  reinterpret<f64>(0x3FE7C00000000000), 0, reinterpret<f64>(0x3FD314F1E1D36000), reinterpret<f64>(0xBD28E27AD3213CB8),\n  reinterpret<f64>(0x3FE7A00000000000), 0, reinterpret<f64>(0x3FD36B6776BE1000), reinterpret<f64>(0x3D116ECDB0F177C8),\n  reinterpret<f64>(0x3FE7800000000000), 0, reinterpret<f64>(0x3FD3C25277333000), reinterpret<f64>(0x3D183B54B606BD5C),\n  reinterpret<f64>(0x3FE7600000000000), 0, reinterpret<f64>(0x3FD419B423D5E800), reinterpret<f64>(0x3D08E436EC90E09D),\n  reinterpret<f64>(0x3FE7400000000000), 0, reinterpret<f64>(0x3FD4718DC271C800), reinterpret<f64>(0xBD2F27CE0967D675),\n  reinterpret<f64>(0x3FE7200000000000), 0, reinterpret<f64>(0x3FD4C9E09E173000), reinterpret<f64>(0xBD2E20891B0AD8A4),\n  reinterpret<f64>(0x3FE7000000000000), 0, reinterpret<f64>(0x3FD522AE0738A000), reinterpret<f64>(0x3D2EBE708164C759),\n  reinterpret<f64>(0x3FE6E00000000000), 0, reinterpret<f64>(0x3FD57BF753C8D000), reinterpret<f64>(0x3D1FADEDEE5D40EF),\n  reinterpret<f64>(0x3FE6C00000000000), 0, reinterpret<f64>(0x3FD5D5BDDF596000), reinterpret<f64>(0xBD0A0B2A08A465DC)\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n  var e = iy >> 52 & 0x7FF;\n  if (e < 0x3FF     ) return 0;\n  if (e > 0x3FF + 52) return 2;\n  e = u64(1) << (0x3FF + 52 - e);\n  if (iy & (e - 1)) return 0;\n  if (iy &  e     ) return 1;\n  return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n  return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n  return xflow(sign, reinterpret<f64>(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n  return xflow(sign, reinterpret<f64>(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n  return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy var log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n  const N = 1 << POW_LOG_TABLE_BITS;\n  const N_MASK = N - 1;\n\n  const\n    Ln2hi = reinterpret<f64>(0x3FE62E42FEFA3800),\n    Ln2lo = reinterpret<f64>(0x3D2EF35793C76730);\n\n  const\n    A0 = reinterpret<f64>(0xBFE0000000000000),\n    A1 = reinterpret<f64>(0xBFE5555555555560),\n    A2 = reinterpret<f64>(0x3FE0000000000006),\n    A3 = reinterpret<f64>(0x3FE999999959554E),\n    A4 = reinterpret<f64>(0xBFE555555529A47A),\n    A5 = reinterpret<f64>(0xBFF2495B9B4845E9),\n    A6 = reinterpret<f64>(0x3FF0002B8B263FC3);\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp = ix - 0x3fE6955500000000;\n  var i   = <usize>((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n  var k   = <i64>tmp >> 52;\n  var iz  = ix - (tmp & u64(0xFFF) << 52);\n  var z   = reinterpret<f64>(iz);\n  var kd  = <f64>k;\n\n  // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n  var invc     = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 0 << alignof<f64>()); // tab[i].invc\n  var logc     = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 2 << alignof<f64>()); // tab[i].logc\n  var logctail = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 3 << alignof<f64>()); // tab[i].logctail\n\n  // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n  // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n  // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n  var zhi = reinterpret<f64>((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n  var zlo = z - zhi;\n  var rhi = zhi * invc - 1.0;\n  var rlo = zlo * invc;\n  var r   = rhi + rlo;\n\n  // k * Ln2 + log(c) + r.\n  var t1  = kd * Ln2hi + logc;\n  var t2  = t1 + r;\n  var lo1 = kd * Ln2lo + logctail;\n  var lo2 = t1 - t2 + r;\n\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  var ar  = A0 * r; // A[0] = -0.5\n  var ar2 = r * ar;\n  var ar3 = r * ar2;\n  // k * Ln2 + log(c) + r + A[0] * r * r.\n  var arhi  = A0  * rhi;\n  var arhi2 = rhi * arhi;\n  var hi    = t2  + arhi2;\n  var lo3   = rlo * (ar + arhi);\n  var lo4   = t2 - hi + arhi2;\n\n  // p = log1p(r) - r - A[0] * r * r.\n  var p  = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n  var lo = lo1 + lo2 + lo3 + lo4 + p;\n  var y  = hi + lo;\n  log_tail = hi - y + lo;\n\n  return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n  const N      = 1 << EXP_TABLE_BITS;\n  const N_MASK = N - 1;\n\n  const\n    InvLn2N   = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n    NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000),     // -0x1.62e42fefa0000p-8\n    NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A),     // -0x1.cf79abc9e3b3ap-47\n    shift     = reinterpret<f64>(0x4338000000000000);     // 0x1.8p52\n\n  const\n    C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n    C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n    C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n    C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n  var abstop: u32;\n  var ki: u64, top: u64, sbits: u64;\n  var idx: usize;\n  // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n  var kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n  var ux = reinterpret<u64>(x);\n  abstop = <u32>(ux >> 52) & 0x7FF;\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) {\n      // Avoid spurious underflow for tiny x.\n      // Note: 0 is common input.\n      return select(-1.0, 1.0, sign_bias);\n    }\n    if (abstop >= 0x409) { // top12(1024.0)\n      // Note: inf and nan are already handled.\n      return ux >> 63 ? uflow(sign_bias) : oflow(sign_bias);\n    }\n    // Large x is special cased below.\n    abstop = 0;\n  }\n\n  // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n  // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n  z = InvLn2N * x;\n\n  // #if TOINT_INTRINSICS\n  //   kd = roundtoint(z);\n  //   ki = converttoint(z);\n  // #elif EXP_USE_TOINT_NARROW\n  //   // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n  //   kd = eval_as_double(z + shift);\n  //   ki = asuint64(kd) >> 16;\n  //   kd = (double_t)(int32_t)ki;\n  // #else\n  // z - kd is in [-1, 1] in non-nearest rounding modes\n  kd  = z + shift;\n  ki  = reinterpret<u64>(kd);\n  kd -= shift;\n  // #endif\n  r = x + kd * NegLn2hiN + kd * NegLn2loN;\n  // The code assumes 2^-200 < |xtail| < 2^-8/N\n  r += xtail;\n  // 2^(k/N) ~= scale * (1 + tail)\n  idx = <usize>((ki & N_MASK) << 1);\n  top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n  tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>())));\n  // This is only a valid scale when -1023*N < k < 1024*N\n  sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top;\n  // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  r2 = r * r;\n  // Without fma the worst case error is 0.25/N ulp larger.\n  // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n  tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase(tmp, sbits, ki);\n  scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n  // is no spurious underflow here even without fma.\n  return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n  const Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  var sign_bias: u32 = 0;\n  var ix = reinterpret<u64>(x);\n  var iy = reinterpret<u64>(y);\n  var topx = ix >> 52;\n  var topy = iy >> 52;\n\n  if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n    // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n    // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n    // Special cases: (x < 0x1p-126 or inf or nan) or\n    // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n    if (zeroinfnan(iy)) {\n      if ((iy << 1) == 0) return 1.0;\n      if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n      if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n      if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n      if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n      return y * y;\n    }\n    if (zeroinfnan(ix)) {\n      let x2 = x * x;\n      if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n      return iy >> 63 ? 1 / x2 : x2;\n    }\n    // Here x and y are non-zero finite\n    if (ix >> 63) {\n      // Finite x < 0\n      let yint = checkint(iy);\n      if (yint == 0) return (x - x) / (x - x);\n      if (yint == 1) sign_bias = SIGN_BIAS;\n      ix   &= 0x7FFFFFFFFFFFFFFF;\n      topx &= 0x7FF;\n    }\n    if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n      // Note: sign_bias == 0 here because y is not odd.\n      if (ix == 0x3FF0000000000000) return 1;\n      if ((topy & 0x7FF) < 0x3BE)   return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n      return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n    }\n    if (topx == 0) {\n      // Normalize subnormal x so exponent becomes negative.\n      ix = reinterpret<u64>(x * Ox1p52);\n      ix &= 0x7FFFFFFFFFFFFFFF;\n      ix -= u64(52) << 52;\n    }\n  }\n\n  var hi = log_inline(ix);\n  var lo = log_tail;\n  var ehi: f64, elo: f64;\n  // #if __FP_FAST_FMA\n  //   ehi = y * hi;\n  //   elo = y * lo + __builtin_fma(y, hi, -ehi);\n  // #else\n  var yhi = reinterpret<f64>(iy & 0xFFFFFFFFF8000000);\n  var ylo = y - yhi;\n  var lhi = reinterpret<f64>(reinterpret<u64>(hi) & 0xFFFFFFFFF8000000);\n  var llo = hi - lhi + lo;\n  ehi = yhi * lhi;\n  elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n  // #endif\n  return exp_inline(ehi, elo, sign_bias);\n}\n","import * as JSMath from \"./bindings/Math\";\nexport { JSMath };\n\nimport {\n  pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n  powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n  abs as builtin_abs,\n  ceil as builtin_ceil,\n  clz as builtin_clz,\n  copysign as builtin_copysign,\n  floor as builtin_floor,\n  max as builtin_max,\n  min as builtin_min,\n  sqrt as builtin_sqrt,\n  trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy var rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data<u64>([\n  0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n  0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n  0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n  0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n  0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n  0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n  const                   // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n    pS0 = reinterpret<f64>(0x3FC5555555555555), //  1.66666666666666657415e-01\n    pS1 = reinterpret<f64>(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n    pS2 = reinterpret<f64>(0x3FC9C1550E884455), //  2.01212532134862925881e-01\n    pS3 = reinterpret<f64>(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n    pS4 = reinterpret<f64>(0x3F49EFE07501B288), //  7.91534994289814532176e-04\n    pS5 = reinterpret<f64>(0x3F023DE10DFDF709), //  3.47933107596021167570e-05\n    qS1 = reinterpret<f64>(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n    qS2 = reinterpret<f64>(0x40002AE59C598AC8), //  2.02094576023350569471e+00\n    qS3 = reinterpret<f64>(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n    qS4 = reinterpret<f64>(0x3FB3B8C5B12E9282); //  7.70381505559019352791e-02\n  var p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n  var q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n  return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n  const                       // see: musl/src/math/__expo2.c\n    k    = <u32>2043,\n    kln2 = reinterpret<f64>(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n  var scale = reinterpret<f64>(<u64>((<u32>0x3FF + k / 2) << 20) << 32);\n  return NativeMath.exp(x - kln2) * scale * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n  // Bits of π/4\n  const p0: u64 = 0xC4C6628B80DC1CD1;\n  const p1: u64 = 0xC90FDAA22168C234;\n\n  const Ox1p_64 = reinterpret<f64>(0x3BF0000000000000); // 0x1p-64\n  const Ox1p_75 = reinterpret<f64>(0x3B40000000000000); // 0x1p-75\n\n  var shift = clz(q1);\n\n  q1 = q1 << shift | q0 >> (64 - shift);\n  q0 <<= shift;\n\n  var lo = umuldi(p1, q1);\n  var hi = res128_hi;\n\n  var ahi = hi >> 11;\n  var alo = lo >> 11 | hi << 53;\n  var blo = <u64>(Ox1p_75 * <f64>p0 * <f64>q1 + Ox1p_75 * <f64>p1 * <f64>q0);\n\n  rempio2_y0 = <f64>(ahi + u64(lo < blo));\n  rempio2_y1 = Ox1p_64 * <f64>(alo + blo);\n\n  return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n  var u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n  u1 = u & 0xFFFFFFFF;\n  v1 = v & 0xFFFFFFFF;\n\n  u >>= 32;\n  v >>= 32;\n\n  t  = u1 * v1;\n  w0 = t & 0xFFFFFFFF;\n  t  = u * v1 + (t >> 32);\n  w1 = t >> 32;\n  t  = u1 * v + (t & 0xFFFFFFFF);\n\n  res128_hi = u * v + w1 + (t >> 32);\n  return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n  var magnitude = u & 0x7FFFFFFFFFFFFFFF;\n  var offset = (magnitude >> 52) - 1045;\n  var shift  = offset & 63;\n  var tblPtr = PIO2_TABLE + (<i32>(offset >> 6) << 3);\n  var s0: u64, s1: u64, s2: u64;\n\n  var b0 = load<u64>(tblPtr, 0 << 3);\n  var b1 = load<u64>(tblPtr, 1 << 3);\n  var b2 = load<u64>(tblPtr, 2 << 3);\n\n  // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n  if (shift) {\n    let rshift = 64 - shift;\n    let b3 = load<u64>(tblPtr, 3 << 3);\n    s0 = b1 >> rshift | b0 << shift;\n    s1 = b2 >> rshift | b1 << shift;\n    s2 = b3 >> rshift | b2 << shift;\n  } else {\n    s0 = b0;\n    s1 = b1;\n    s2 = b2;\n  }\n\n  var significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n  // First 128 bits of fractional part of x/(2π)\n  var blo = umuldi(s1, significand);\n  var bhi = res128_hi;\n\n  var ahi = s0 * significand;\n  var clo = (s2 >> 32) * (significand >> 32);\n  var plo = blo + clo;\n  var phi = ahi + bhi + u64(plo < clo);\n\n  // r: u128 = p << 2\n  var rlo = plo << 2;\n  var rhi = phi << 2 | plo >> 62;\n\n  // s: i128 = r >> 127\n  var slo = <i64>rhi >> 63;\n  var shi = slo >> 1;\n  var q   = (<i64>phi >> 62) - slo;\n\n  var shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n  var signbit = (u ^ rhi) & 0x8000000000000000;\n  var coeff = reinterpret<f64>(shifter | signbit);\n\n  rempio2_y0 *= coeff;\n  rempio2_y1 *= coeff;\n\n  return <i32>q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n  const pio2_1  = reinterpret<f64>(0x3FF921FB54400000); // 1.57079632673412561417e+00\n  const pio2_1t = reinterpret<f64>(0x3DD0B4611A626331); // 6.07710050650619224932e-11\n  const pio2_2  = reinterpret<f64>(0x3DD0B4611A600000); // 6.07710050630396597660e-11\n  const pio2_2t = reinterpret<f64>(0x3BA3198A2E037073); // 2.02226624879595063154e-21\n  const pio2_3  = reinterpret<f64>(0x3BA3198A2E000000); // 2.02226624871116645580e-21\n  const pio2_3t = reinterpret<f64>(0x397B839A252049C1); // 8.47842766036889956997e-32\n  const invpio2 = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n  var ix = <u32>(u >> 32) & 0x7FFFFFFF;\n\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n      let q = 1, z: f64, y0: f64, y1: f64;\n      if (!sign) {\n        z = x - pio2_1;\n        if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n          y0 = z - pio2_1t;\n          y1 = (z - y0) - pio2_1t;\n        } else { // near pi/2, use 33+33+53 bit pi\n          z -= pio2_2;\n          y0 = z - pio2_2t;\n          y1 = (z - y0) - pio2_2t;\n        }\n      } else { // negative x\n        z = x + pio2_1;\n        if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n          y0 = z + pio2_1t;\n          y1 = (z - y0) + pio2_1t;\n        } else { // near pi/2, use 33+33+53 bit pi\n          z += pio2_2;\n          y0 = z + pio2_2t;\n          y1 = (z - y0) + pio2_2t;\n        }\n        q = -1;\n      }\n      rempio2_y0 = y0;\n      rempio2_y1 = y1;\n      return q;\n    }\n  }\n\n  if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n    // Use precise Cody Waite scheme\n    let q  = nearest(x * invpio2);\n    let r  = x - q * pio2_1;\n    let w  = q * pio2_1t; // 1st round good to 85 bit\n    let j  = ix >> 20;\n    let y0 = r - w;\n    let hi = <u32>(reinterpret<u64>(y0) >> 32);\n    let i  = j - ((hi >> 20) & 0x7FF);\n\n    if (i > 16) { // 2nd iteration needed, good to 118\n      let t = r;\n      w  = q * pio2_2;\n      r  = t - w;\n      w  = q * pio2_2t - ((t - r) - w);\n      y0 = r - w;\n      hi = <u32>(reinterpret<u64>(y0) >> 32);\n      i = j - ((hi >> 20) & 0x7FF);\n      if (i > 49) { // 3rd iteration need, 151 bits acc\n        let t = r;\n        w  = q * pio2_3;\n        r  = t - w;\n        w  = q * pio2_3t - ((t - r) - w);\n        y0 = r - w;\n      }\n    }\n    let y1 = (r - y0) - w;\n    rempio2_y0 = y0;\n    rempio2_y1 = y1;\n    return <i32>q;\n  }\n  var q = pio2_large_quot(x, u);\n  return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n  const S1 = reinterpret<f64>(0xBFC5555555555549); // -1.66666666666666324348e-01\n  const S2 = reinterpret<f64>(0x3F8111111110F8A6); //  8.33333333332248946124e-03\n  const S3 = reinterpret<f64>(0xBF2A01A019C161D5); // -1.98412698298579493134e-04\n  const S4 = reinterpret<f64>(0x3EC71DE357B1FE7D); //  2.75573137070700676789e-06\n  const S5 = reinterpret<f64>(0xBE5AE5E68A2B9CEB); // -2.50507602534068634195e-08\n  const S6 = reinterpret<f64>(0x3DE5D93A5ACFD57C); //  1.58969099521155010221e-10\n\n  var z = x * x;\n  var w = z * z;\n  var r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n  var v = z * x;\n  if (!iy) {\n    return x + v * (S1 + z * r);\n  } else {\n    return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n  }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n  const C1 = reinterpret<f64>(0x3FA555555555554C); //  4.16666666666666019037e-02\n  const C2 = reinterpret<f64>(0xBF56C16C16C15177); // -1.38888888888741095749e-03\n  const C3 = reinterpret<f64>(0x3EFA01A019CB1590); //  2.48015872894767294178e-05\n  const C4 = reinterpret<f64>(0xBE927E4F809C52AD); // -2.75573143513906633035e-07\n  const C5 = reinterpret<f64>(0x3E21EE9EBDB4B1C4); //  2.08757232129817482790e-09\n  const C6 = reinterpret<f64>(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n  var z = x * x;\n  var w = z * z;\n  var r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n  var hz = 0.5 * z;\n  w = 1.0 - hz;\n  return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n  const T0  = reinterpret<f64>(0x3FD5555555555563); //  3.33333333333334091986e-01\n  const T1  = reinterpret<f64>(0x3FC111111110FE7A); //  1.33333333333201242699e-01\n  const T2  = reinterpret<f64>(0x3FABA1BA1BB341FE); //  5.39682539762260521377e-02\n  const T3  = reinterpret<f64>(0x3F9664F48406D637); //  2.18694882948595424599e-02\n  const T4  = reinterpret<f64>(0x3F8226E3E96E8493); //  8.86323982359930005737e-03\n  const T5  = reinterpret<f64>(0x3F6D6D22C9560328); //  3.59207910759131235356e-03\n  const T6  = reinterpret<f64>(0x3F57DBC8FEE08315); //  1.45620945432529025516e-03\n  const T7  = reinterpret<f64>(0x3F4344D8F2F26501); //  5.88041240820264096874e-04\n  const T8  = reinterpret<f64>(0x3F3026F71A8D1068); //  2.46463134818469906812e-04\n  const T9  = reinterpret<f64>(0x3F147E88A03792A6); //  7.81794442939557092300e-05\n  const T10 = reinterpret<f64>(0x3F12B80F32F0A7E9); //  7.14072491382608190305e-05\n  const T11 = reinterpret<f64>(0xBEF375CBDB605373); // -1.85586374855275456654e-05\n  const T12 = reinterpret<f64>(0x3EFB2A7074BF7AD4); //  2.59073051863633712884e-05\n\n  const one    = reinterpret<f64>(0x3FF0000000000000); // 1.00000000000000000000e+00\n  const pio4   = reinterpret<f64>(0x3FE921FB54442D18); // 7.85398163397448278999e-01\n  const pio4lo = reinterpret<f64>(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n  var z: f64, r: f64, v: f64, w: f64, s: f64;\n  var hx = <i32>(reinterpret<u64>(x) >> 32); // high word of x\n  var ix = hx & 0x7FFFFFFF; // high word of |x|\n  var big = ix >= 0x3FE59428;\n  if (big) { // |x| >= 0.6744\n    if (hx < 0) { x = -x, y = -y; }\n    z = pio4 - x;\n    w = pio4lo - y;\n    x = z + w;\n    y = 0.0;\n  }\n  z = x * x;\n  w = z * z;\n  r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n  v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n  s = z * x;\n  r = y + z * (s * (r + v) + y);\n  r += T0 * s;\n  w = x + r;\n  if (big) {\n    v = iy;\n    return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n  }\n  if (iy == 1) return w;\n  var a: f64, t: f64;\n  z = w;\n  z = reinterpret<f64>(reinterpret<u64>(z) & 0xFFFFFFFF00000000);\n  v = r - (z - x);  // z + v = r + x\n  t = a = -one / w; // a = -1.0 / w\n  t = reinterpret<f64>(reinterpret<u64>(t) & 0xFFFFFFFF00000000);\n  s = one + t * z;\n  return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    const inv32 = 1.0 / 4294967296;\n    return <i32><i64>(x - 4294967296 * floor(x * inv32));\n  } else {\n    let result = 0;\n    let u = reinterpret<u64>(x);\n    let e = (u >> 52) & 0x7FF;\n    if (e <= 1023 + 30) {\n      result = <i32>x;\n    } else if (e <= 1023 + 30 + 53) {\n      let v = (u & ((<u64>1 << 52) - 1)) | (<u64>1 << 52);\n      v = v << e - 1023 - 52 + 32;\n      result = <i32>(v >> 32);\n      result = select<i32>(-result, result, u >> 63);\n    }\n    return result;\n  }\n}\n\n// @ts-ignore: decorator\n@lazy var random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy var random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy var random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n  h ^= h >> 33;                     // see: https://github.com/aappleby/smhasher\n  h *= 0xFF51AFD7ED558CCD;\n  h ^= h >> 33;\n  h *= 0xC4CEB9FE1A85EC53;\n  h ^= h >> 33;\n  return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n  h += 0x6D2B79F5;\n  h  = (h ^ (h >> 15)) * (h | 1);\n  h ^= h + (h ^ (h >> 7)) * (h | 61);\n  return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const E       = reinterpret<f64>(0x4005BF0A8B145769); // 2.7182818284590452354\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN2     = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN10    = reinterpret<f64>(0x40026BB1BBB55516); // 2.30258509299404568402\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG2E   = reinterpret<f64>(0x3FF71547652B82FE); // 1.4426950408889634074\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG10E  = reinterpret<f64>(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n  // @ts-ignore: decorator\n  @lazy\n  export const PI      = reinterpret<f64>(0x400921FB54442D18); // 3.14159265358979323846\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT1_2 = reinterpret<f64>(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT2   = reinterpret<f64>(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n  // @ts-ignore: decorator\n  @lazy\n  export var sincos_sin: f64 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export var sincos_cos: f64 = 0;\n\n  // @ts-ignore: decorator\n  @inline export function abs(x: f64): f64 {\n    return builtin_abs<f64>(x);\n  }\n\n  export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f64>(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n      pio2_lo   = reinterpret<f64>(0x3C91A62633145C07), // 6.12323399573676603587e-17\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n    var hx = <u32>(reinterpret<u64>(x) >> 32);\n    var ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3FF00000) {\n      let lx = <u32>reinterpret<u64>(x);\n      if ((ix - 0x3FF00000 | lx) == 0) {\n        if (hx >> 31) return 2 * pio2_hi + Ox1p_120f;\n        return 0;\n      }\n      return 0 / (x - x);\n    }\n    if (ix < 0x3FE00000) {\n      if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n      return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n    }\n    var s: f64, w: f64, z: f64;\n    if (hx >> 31) {\n      // z = (1.0 + x) * 0.5;\n      z = 0.5 + x * 0.5;\n      s = builtin_sqrt<f64>(z);\n      w = R(z) * s - pio2_lo;\n      return 2 * (pio2_hi - (s + w));\n    }\n    // z = (1.0 - x) * 0.5;\n    z = 0.5 - x * 0.5;\n    s = builtin_sqrt<f64>(z);\n    var df = reinterpret<f64>(reinterpret<u64>(s) & 0xFFFFFFFF00000000);\n    var c = (z - df * df) / (s + df);\n    w = R(z) * s + c;\n    return 2 * (df + w);\n  }\n\n  export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n    const s = reinterpret<f64>(0x3FE62E42FEFA39EF);\n    var e = reinterpret<u64>(x) >> 52 & 0x7FF;\n    if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt<f64>((x - 1) * (x - 1) + 2 * (x - 1)));\n    if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt<f64>(x * x - 1)));\n    return log(x) + s;\n  }\n\n  export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f64>(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n      pio2_lo   = reinterpret<f64>(0x3C91A62633145C07), // 6.12323399573676603587e-17\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n    var hx = <u32>(reinterpret<u64>(x) >> 32);\n    var ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3FF00000) {\n      let lx = <u32>reinterpret<u64>(x);\n      if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n      return 0 / (x - x);\n    }\n    if (ix < 0x3FE00000) {\n      if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n      return x + x * R(x * x);\n    }\n    // var z = (1.0 - builtin_abs<f64>(x)) * 0.5;\n    var z = 0.5 - builtin_abs<f64>(x) * 0.5;\n    var s = builtin_sqrt<f64>(z);\n    var r = R(z);\n    if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n    else {\n      let f = reinterpret<f64>(reinterpret<u64>(s) & 0xFFFFFFFF00000000);\n      let c = (z - f * f) / (s + f);\n      x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n    }\n    if (hx >> 31) return -x;\n    return x;\n  }\n\n  export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n    const c = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n    var u = reinterpret<u64>(x);\n    var e = u >> 52 & 0x7FF;\n    var y = reinterpret<f64>(u & 0x7FFFFFFFFFFFFFFF);\n    if (e >= 0x3FF + 26) y = log(y) + c;\n    else if (e >= 0x3FF + 1)  y =   log(2 * y + 1 / (builtin_sqrt<f64>(y * y + 1) + y));\n    else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt<f64>(y * y + 1) + 1));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n    const\n      atanhi0   = reinterpret<f64>(0x3FDDAC670561BB4F), //  4.63647609000806093515e-01\n      atanhi1   = reinterpret<f64>(0x3FE921FB54442D18), //  7.85398163397448278999e-01\n      atanhi2   = reinterpret<f64>(0x3FEF730BD281F69B), //  9.82793723247329054082e-01\n      atanhi3   = reinterpret<f64>(0x3FF921FB54442D18), //  1.57079632679489655800e+00\n      atanlo0   = reinterpret<f64>(0x3C7A2B7F222F65E2), //  2.26987774529616870924e-17\n      atanlo1   = reinterpret<f64>(0x3C81A62633145C07), //  3.06161699786838301793e-17\n      atanlo2   = reinterpret<f64>(0x3C7007887AF0CBBD), //  1.39033110312309984516e-17\n      atanlo3   = reinterpret<f64>(0x3C91A62633145C07), //  6.12323399573676603587e-17\n      aT0       = reinterpret<f64>(0x3FD555555555550D), //  3.33333333333329318027e-01\n      aT1       = reinterpret<f64>(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n      aT2       = reinterpret<f64>(0x3FC24924920083FF), //  1.42857142725034663711e-01\n      aT3       = reinterpret<f64>(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n      aT4       = reinterpret<f64>(0x3FB745CDC54C206E), //  9.09088713343650656196e-02\n      aT5       = reinterpret<f64>(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n      aT6       = reinterpret<f64>(0x3FB10D66A0D03D51), //  6.66107313738753120669e-02\n      aT7       = reinterpret<f64>(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n      aT8       = reinterpret<f64>(0x3FA97B4B24760DEB), //  4.97687799461593236017e-02\n      aT9       = reinterpret<f64>(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n      aT10      = reinterpret<f64>(0x3F90AD3AE322DA11), //  1.62858201153657823623e-02\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n    var ix = <u32>(reinterpret<u64>(x) >> 32);\n    var sx = x;\n    ix &= 0x7FFFFFFF;\n    var z: f64;\n    if (ix >= 0x44100000) {\n      if (isNaN(x)) return x;\n      z = atanhi3 + Ox1p_120f;\n      return builtin_copysign<f64>(z, sx);\n    }\n    var id: i32;\n    if (ix < 0x3FDC0000) {\n      if (ix < 0x3E400000) return x;\n      id = -1;\n    } else {\n      x = builtin_abs<f64>(x);\n      if (ix < 0x3FF30000) {\n        if (ix < 0x3FE60000) {\n          id = 0;\n          x = (2.0 * x - 1.0) / (2.0 + x);\n        } else {\n          id = 1;\n          x = (x - 1.0) / (x + 1.0);\n        }\n      } else {\n        if (ix < 0x40038000) {\n          id = 2;\n          x = (x - 1.5) / (1.0 + 1.5 * x);\n        } else {\n          id = 3;\n          x = -1.0 / x;\n        }\n      }\n    }\n    z = x * x;\n    var w = z * z;\n    var s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n    var s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n    var s3 = x * (s1 + s2);\n    if (id < 0) return x - s3;\n    switch (id) {\n      case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n      case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n      case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n      case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n      default: unreachable();\n    }\n    return builtin_copysign<f64>(z, sx);\n  }\n\n  export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n    var u = reinterpret<u64>(x);\n    var e = u >> 52 & 0x7FF;\n    var y = builtin_abs(x);\n    if (e < 0x3FF - 1) {\n      if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n    } else {\n      y = 0.5 * log1p(2 * (y / (1 - y)));\n    }\n    return builtin_copysign<f64>(y, x);\n  }\n\n  export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n    const pi_lo = reinterpret<f64>(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n    if (isNaN(x) || isNaN(y)) return x + y;\n    var u = reinterpret<u64>(x);\n    var ix = <u32>(u >> 32);\n    var lx = <u32>u;\n    u = reinterpret<u64>(y);\n    var iy = <u32>(u >> 32);\n    var ly = <u32>u;\n    if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n    var m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n    ix = ix & 0x7FFFFFFF;\n    iy = iy & 0x7FFFFFFF;\n    if ((iy | ly) == 0) {\n      switch (m) {\n        case 0:\n        case 1: return  y;\n        case 2: return  PI;\n        case 3: return -PI;\n      }\n    }\n    if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n    if (ix == 0x7FF00000) {\n      if (iy == 0x7FF00000) {\n        let t = m & 2 ? 3 * PI / 4 : PI / 4;\n        return m & 1 ? -t : t;\n      } else {\n        let t = m & 2 ? PI : 0;\n        return m & 1 ? -t : t;\n      }\n    }\n    var z: f64;\n    if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n    if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n    else z = atan(builtin_abs<f64>(y / x));\n    switch (m) {\n      case 0: return  z;\n      case 1: return -z;\n      case 2: return PI - (z - pi_lo);\n      case 3: return (z - pi_lo) - PI;\n    }\n    unreachable();\n    return 0;\n  }\n\n  export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n    const\n      B1     = <u32>715094163,\n      B2     = <u32>696219795,\n      P0     = reinterpret<f64>(0x3FFE03E60F61E692), //  1.87595182427177009643\n      P1     = reinterpret<f64>(0xBFFE28E092F02420), // -1.88497979543377169875\n      P2     = reinterpret<f64>(0x3FF9F1604A49D6C2), //  1.621429720105354466140\n      P3     = reinterpret<f64>(0xBFE844CBBEE751D9), // -0.758397934778766047437\n      P4     = reinterpret<f64>(0x3FC2B000D4E4EDD7), //  0.145996192886612446982\n      Ox1p54 = reinterpret<f64>(0x4350000000000000);\n    var u = reinterpret<u64>(x);\n    var hx = <u32>(u >> 32) & 0x7FFFFFFF;\n    if (hx >= 0x7FF00000) return x + x;\n    if (hx < 0x00100000) {\n      u = reinterpret<u64>(x * Ox1p54);\n      hx = <u32>(u >> 32) & 0x7FFFFFFF;\n      if (hx == 0) return x;\n      hx = hx / 3 + B2;\n    } else {\n      hx = hx / 3 + B1;\n    }\n    u &= 1 << 63;\n    u |= <u64>hx << 32;\n    var t = reinterpret<f64>(u);\n    var r = (t * t) * (t / x);\n    t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n    t = reinterpret<f64>((reinterpret<u64>(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n    var s = t * t;\n    r = x / s;\n    r = (r - t) / (2 * t + r);\n    t = t + t * r;\n    return t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function ceil(x: f64): f64 {\n    return builtin_ceil<f64>(x);\n  }\n\n  export function clz32(x: f64): f64 {\n    if (!isFinite(x)) return 32;\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    return builtin_clz(dtoi32(x));\n  }\n\n  export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n    var u  = reinterpret<u64>(x);\n    var ix = <u32>(u >> 32);\n    var sign = ix >> 31;\n\n    ix &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ix <= 0x3FE921FB) {\n      if (ix < 0x3E46A09E) {  // |x| < 2**-27 * sqrt(2)\n        return 1.0;\n      }\n      return cos_kern(x, 0);\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7FF00000) return x - x;\n\n    // argument reduction needed\n    var n  = rempio2(x, u, sign);\n    var y0 = rempio2_y0;\n    var y1 = rempio2_y1;\n\n    x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n    return (n + 1) & 2 ? -x : x;\n  }\n\n  export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n    var u = reinterpret<u64>(x);\n    u &= 0x7FFFFFFFFFFFFFFF;\n    x = reinterpret<f64>(u);\n    var w = <u32>(u >> 32);\n    var t: f64;\n    if (w < 0x3FE62E42) {\n      if (w < 0x3FF00000 - (26 << 20)) return 1;\n      t = expm1(x);\n      // return 1 + t * t / (2 * (1 + t));\n      return 1 + t * t / (2 + 2 * t);\n    }\n    if (w < 0x40862E42) {\n      t = exp(x);\n      return 0.5 * (t + 1 / t);\n    }\n    t = expo2(x);\n    return t;\n  }\n\n  export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return exp_lut(x);\n    } else {\n      const\n        ln2hi     = reinterpret<f64>(0x3FE62E42FEE00000), //  6.93147180369123816490e-01\n        ln2lo     = reinterpret<f64>(0x3DEA39EF35793C76), //  1.90821492927058770002e-10\n        invln2    = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n        P1        = reinterpret<f64>(0x3FC555555555553E), //  1.66666666666666019037e-01\n        P2        = reinterpret<f64>(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n        P3        = reinterpret<f64>(0x3F11566AAF25DE2C), //  6.61375632143793436117e-05\n        P4        = reinterpret<f64>(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n        P5        = reinterpret<f64>(0x3E66376972BEA4D0), //  4.13813679705723846039e-08\n        overflow  = reinterpret<f64>(0x40862E42FEFA39EF), //  709.782712893383973096\n        underflow = reinterpret<f64>(0xC0874910D52D3051), // -745.13321910194110842\n        Ox1p1023  = reinterpret<f64>(0x7FE0000000000000);\n      let hx = <u32>(reinterpret<u64>(x) >> 32);\n      let sign_ = <i32>(hx >> 31);\n      hx &= 0x7FFFFFFF;\n      if (hx >= 0x4086232B) {\n        if (isNaN(x)) return x;\n        if (x > overflow)  return x * Ox1p1023;\n        if (x < underflow) return 0;\n      }\n      let hi: f64, lo: f64 = 0;\n      let k = 0;\n      if (hx > 0x3FD62E42) {\n        if (hx >= 0x3FF0A2B2) {\n          k = <i32>(invln2 * x + builtin_copysign<f64>(0.5, x));\n        } else {\n          k = 1 - (sign_ << 1);\n        }\n        hi = x - k * ln2hi;\n        lo = k * ln2lo;\n        x = hi - lo;\n      } else if (hx > 0x3E300000) {\n        hi = x;\n      } else return 1.0 + x;\n      let xs = x * x;\n      // var c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n      let xq = xs * xs;\n      let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n      let y = 1.0 + (x * c / (2 - c) - lo + hi);\n      return k == 0 ? y : scalbn(y, k);\n    }\n  }\n\n  export function exp2(x: f64): f64 {\n    return exp2_lut(x);\n  }\n\n  export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n    const\n      o_threshold = reinterpret<f64>(0x40862E42FEFA39EF), //  7.09782712893383973096e+02\n      ln2_hi      = reinterpret<f64>(0x3FE62E42FEE00000), //  6.93147180369123816490e-01\n      ln2_lo      = reinterpret<f64>(0x3DEA39EF35793C76), //  1.90821492927058770002e-10\n      invln2      = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n      Q1          = reinterpret<f64>(0xBFA11111111110F4), // -3.33333333333331316428e-02\n      Q2          = reinterpret<f64>(0x3F5A01A019FE5585), //  1.58730158725481460165e-03\n      Q3          = reinterpret<f64>(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n      Q4          = reinterpret<f64>(0x3ED0CFCA86E65239), //  4.00821782732936239552e-06\n      Q5          = reinterpret<f64>(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n      Ox1p1023    = reinterpret<f64>(0x7FE0000000000000);\n    var u = reinterpret<u64>(x);\n    var hx = <u32>(u >> 32 & 0x7FFFFFFF);\n    var k = 0, sign_ = <i32>(u >> 63);\n    if (hx >= 0x4043687A) {\n      if (isNaN(x)) return x;\n      if (sign_) return -1;\n      if (x > o_threshold) return x * Ox1p1023;\n    }\n    var c = 0.0, t: f64;\n    if (hx > 0x3FD62E42) {\n      k = select<i32>(\n        1 - (sign_ << 1),\n        <i32>(invln2 * x + builtin_copysign<f64>(0.5, x)),\n        hx < 0x3FF0A2B2\n      );\n      t = <f64>k;\n      let hi = x - t * ln2_hi;\n      let lo = t * ln2_lo;\n      x = hi - lo;\n      c = (hi - x) - lo;\n    } else if (hx < 0x3C900000) return x;\n    var hfx = 0.5 * x;\n    var hxs = x * hfx;\n    // var r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n    var hxq = hxs * hxs;\n    var r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n    t = 3.0 - r1 * hfx;\n    var e = hxs * ((r1 - t) / (6.0 - x * t));\n    if (k == 0) return x - (x * e - hxs);\n    e = x * (e - c) - c;\n    e -= hxs;\n    if (k == -1) return 0.5 * (x - e) - 0.5;\n    if (k == 1) {\n      if (x < -0.25) return -2.0 * (e - (x + 0.5));\n      return 1.0 + 2.0 * (x - e);\n    }\n    u = (0x3FF + k) << 52;\n    var twopk = reinterpret<f64>(u);\n    var y: f64;\n    if (k < 0 || k > 56) {\n      y = x - e + 1.0;\n      if (k == 1024) y = y * 2.0 * Ox1p1023;\n      else y = y * twopk;\n      return y - 1.0;\n    }\n    u = (0x3FF - k) << 52;\n    y = reinterpret<f64>(u);\n    if (k < 20) y = (1 - y) - e;\n    else y = 1 - (e + y);\n    return (x + y) * twopk;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function floor(x: f64): f64 {\n    return builtin_floor<f64>(x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function fround(x: f64): f64 {\n    return <f32>x;\n  }\n\n  export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n    const\n      SPLIT    = reinterpret<f64>(0x41A0000000000000) + 1, // 0x1p27 + 1\n      Ox1p700  = reinterpret<f64>(0x6BB0000000000000),\n      Ox1p_700 = reinterpret<f64>(0x1430000000000000);\n    var ux = reinterpret<u64>(x);\n    var uy = reinterpret<u64>(y);\n    ux &= 0x7FFFFFFFFFFFFFFF;\n    uy &= 0x7FFFFFFFFFFFFFFF;\n    if (ux < uy) {\n      let ut = ux;\n      ux = uy;\n      uy = ut;\n    }\n    var ex = <i32>(ux >> 52);\n    var ey = <i32>(uy >> 52);\n    y = reinterpret<f64>(uy);\n    if (ey == 0x7FF) return y;\n    x = reinterpret<f64>(ux);\n    if (ex == 0x7FF || uy == 0) return x;\n    if (ex - ey > 64) return x + y;\n    var z = 1.0;\n    if (ex > 0x3FF + 510) {\n      z  = Ox1p700;\n      x *= Ox1p_700;\n      y *= Ox1p_700;\n    } else if (ey < 0x3FF - 450) {\n      z  = Ox1p_700;\n      x *= Ox1p700;\n      y *= Ox1p700;\n    }\n    var c = x * SPLIT;\n    var h = x - c + c;\n    var l = x - h;\n    var hx = x * x;\n    var lx = h * h - hx + (2 * h + l) * l;\n    c = y * SPLIT;\n    h = y - c + c;\n    l = y - h;\n    var hy = y * y;\n    var ly = h * h - hy + (2 * h + l) * l;\n    return z * builtin_sqrt(ly + lx + hy + hx);\n  }\n\n  export function imul(x: f64, y: f64): f64 {\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    if (!isFinite(x + y)) return 0;\n    return dtoi32(x) * dtoi32(y);\n  }\n\n  export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log_lut(x);\n    } else {\n      const\n        ln2_hi = reinterpret<f64>(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n        ln2_lo = reinterpret<f64>(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n        Lg1    = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n        Lg2    = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n        Lg3    = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n        Lg4    = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n        Lg5    = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n        Lg6    = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n        Lg7    = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n        Ox1p54 = reinterpret<f64>(0x4350000000000000);\n      let u = reinterpret<u64>(x);\n      let hx = <u32>(u >> 32);\n      let k = 0;\n      if (hx < 0x00100000 || <bool>(hx >> 31)) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (hx >> 31)    return (x - x) / 0.0;\n        k -= 54;\n        x *= Ox1p54;\n        u = reinterpret<u64>(x);\n        hx = <u32>(u >> 32);\n      } else if (hx >= 0x7FF00000) {\n        return x;\n      } else if (hx == 0x3FF00000 && u << 32 == 0) {\n        return 0;\n      }\n      hx += 0x3FF00000 - 0x3FE6A09E;\n      k += (<i32>hx >> 20) - 0x3FF;\n      hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n      x = reinterpret<f64>(u);\n      let f = x - 1.0;\n      let hfsq = 0.5 * f * f;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n      let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n      let r = t2 + t1;\n      let dk = <f64>k;\n      return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n    }\n  }\n\n  export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n    const\n      ivln10hi  = reinterpret<f64>(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n      ivln10lo  = reinterpret<f64>(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n      log10_2hi = reinterpret<f64>(0x3FD34413509F6000), // 3.01029995663611771306e-01\n      log10_2lo = reinterpret<f64>(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n      Lg1       = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n      Lg2       = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n      Lg3       = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n      Lg4       = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n      Lg5       = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n      Lg6       = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n      Lg7       = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n      Ox1p54    = reinterpret<f64>(0x4350000000000000);\n    var u = reinterpret<u64>(x);\n    var hx = <u32>(u >> 32);\n    var k = 0;\n    if (hx < 0x00100000 || <bool>(hx >> 31)) {\n      if (u << 1 == 0) return -1 / (x * x);\n      if (hx >> 31) return (x - x) / 0.0;\n      k -= 54;\n      x *= Ox1p54;\n      u = reinterpret<u64>(x);\n      hx = <u32>(u >> 32);\n    } else if (hx >= 0x7FF00000) {\n      return x;\n    } else if (hx == 0x3FF00000 && u << 32 == 0) {\n      return 0;\n    }\n    hx += 0x3FF00000 - 0x3FE6A09E;\n    k += <i32>(hx >> 20) - 0x3FF;\n    hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n    u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n    x = reinterpret<f64>(u);\n    var f = x - 1.0;\n    var hfsq = 0.5 * f * f;\n    var s = f / (2.0 + f);\n    var z = s * s;\n    var w = z * z;\n    var t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n    var t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n    var r = t2 + t1;\n    var hi = f - hfsq;\n    u = reinterpret<u64>(hi);\n    u &= 0xFFFFFFFF00000000;\n    hi = reinterpret<f64>(u);\n    var lo = f - hi - hfsq + s * (hfsq + r);\n    var val_hi = hi * ivln10hi;\n    var dk = <f64>k;\n    var y = dk * log10_2hi;\n    var val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n    w = y + val_hi;\n    val_lo += (y - w) + val_hi;\n    return val_lo + w;\n  }\n\n  export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi = reinterpret<f64>(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n      ln2_lo = reinterpret<f64>(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n      Lg1    = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n      Lg2    = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n      Lg3    = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n      Lg4    = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n      Lg5    = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n      Lg6    = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n      Lg7    = reinterpret<f64>(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n    var u = reinterpret<u64>(x);\n    var hx = <u32>(u >> 32);\n    var k = 1;\n    var c = 0.0, f = 0.0;\n    if (hx < 0x3FDA827A || <bool>(hx >> 31)) {\n      if (hx >= 0xBFF00000) {\n        if (x == -1) return x / 0.0;\n        return (x - x) / 0.0;\n      }\n      if (hx << 1 < 0x3CA00000 << 1) return x;\n      if (hx <= 0xBFD2BEC4) {\n        k = 0;\n        c = 0;\n        f = x;\n      }\n    } else if (hx >= 0x7FF00000) return x;\n    if (k) {\n      u = reinterpret<u64>(1 + x);\n      let hu = <u32>(u >> 32);\n      hu += 0x3FF00000 - 0x3FE6A09E;\n      k = <i32>(hu >> 20) - 0x3FF;\n      if (k < 54) {\n        let uf = reinterpret<f64>(u);\n        c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n        c /= uf;\n      } else c = 0;\n      hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hu << 32 | (u & 0xFFFFFFFF);\n      f = reinterpret<f64>(u) - 1;\n    }\n    var hfsq = 0.5 * f * f;\n    var s = f / (2.0 + f);\n    var z = s * s;\n    var w = z * z;\n    var t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n    var t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n    var r = t2 + t1;\n    var dk = <f64>k;\n    return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n  }\n\n  export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log2_lut(x);\n    } else {\n      const\n        ivln2hi = reinterpret<f64>(0x3FF7154765200000), // 1.44269504072144627571e+00\n        ivln2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n        Lg1     = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n        Lg2     = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n        Lg3     = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n        Lg4     = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n        Lg5     = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n        Lg6     = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n        Lg7     = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n        Ox1p54  = reinterpret<f64>(0x4350000000000000);\n      let u = reinterpret<u64>(x);\n      let hx = <u32>(u >> 32);\n      let k = 0;\n      if (hx < 0x00100000 || <bool>(hx >> 31)) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (hx >> 31) return (x - x) / 0.0;\n        k -= 54;\n        x *= Ox1p54;\n        u = reinterpret<u64>(x);\n        hx = <u32>(u >> 32);\n      } else if (hx >= 0x7FF00000) {\n        return x;\n      } else if (hx == 0x3FF00000 && u << 32 == 0) {\n        return 0;\n      }\n      hx += 0x3FF00000 - 0x3FE6A09E;\n      k += <i32>(hx >> 20) - 0x3FF;\n      hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n      x = reinterpret<f64>(u);\n      let f = x - 1.0;\n      let hfsq = 0.5 * f * f;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n      let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n      let r = t2 + t1;\n      let hi = f - hfsq;\n      u = reinterpret<u64>(hi);\n      u &= 0xFFFFFFFF00000000;\n      hi = reinterpret<f64>(u);\n      let lo = f - hi - hfsq + s * (hfsq + r);\n      let val_hi = hi * ivln2hi;\n      let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n      let y = <f64>k;\n      w = y + val_hi;\n      val_lo += (y - w) + val_hi;\n      val_hi = w;\n      return val_lo + val_hi;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function max(value1: f64, value2: f64): f64 {\n    return builtin_max<f64>(value1, value2);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function min(value1: f64, value2: f64): f64 {\n    return builtin_min<f64>(value1, value2);\n  }\n\n  export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n    // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n    if (builtin_abs<f64>(y) <= 2) {\n      if (y == 2.0) return x * x;\n      if (y == 0.5) {\n        return select<f64>(\n          builtin_abs<f64>(builtin_sqrt<f64>(x)),\n          Infinity,\n          x != -Infinity\n        );\n      }\n      if (y == -1.0) return 1 / x;\n      if (y == 1.0) return x;\n      if (y == 0.0) return 1.0;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      return pow_lut(x, y);\n    } else {\n      const\n        dp_h1   = reinterpret<f64>(0x3FE2B80340000000), //  5.84962487220764160156e-01\n        dp_l1   = reinterpret<f64>(0x3E4CFDEB43CFD006), //  1.35003920212974897128e-08\n        two53   = reinterpret<f64>(0x4340000000000000), //  9007199254740992.0\n        huge    = reinterpret<f64>(0x7E37E43C8800759C), //  1e+300\n        tiny    = reinterpret<f64>(0x01A56E1FC2F8F359), //  1e-300\n        L1      = reinterpret<f64>(0x3FE3333333333303), //  5.99999999999994648725e-01\n        L2      = reinterpret<f64>(0x3FDB6DB6DB6FABFF), //  4.28571428578550184252e-01\n        L3      = reinterpret<f64>(0x3FD55555518F264D), //  3.33333329818377432918e-01\n        L4      = reinterpret<f64>(0x3FD17460A91D4101), //  2.72728123808534006489e-01\n        L5      = reinterpret<f64>(0x3FCD864A93C9DB65), //  2.30660745775561754067e-01\n        L6      = reinterpret<f64>(0x3FCA7E284A454EEF), //  2.06975017800338417784e-01\n        P1      = reinterpret<f64>(0x3FC555555555553E), //  1.66666666666666019037e-01\n        P2      = reinterpret<f64>(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n        P3      = reinterpret<f64>(0x3F11566AAF25DE2C), //  6.61375632143793436117e-05\n        P4      = reinterpret<f64>(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n        P5      = reinterpret<f64>(0x3E66376972BEA4D0), //  4.13813679705723846039e-08\n        lg2     = reinterpret<f64>(0x3FE62E42FEFA39EF), //  6.93147180559945286227e-01\n        lg2_h   = reinterpret<f64>(0x3FE62E4300000000), //  6.93147182464599609375e-01\n        lg2_l   = reinterpret<f64>(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n        ovt     = reinterpret<f64>(0x3C971547652B82FE), //  8.0085662595372944372e-017\n        cp      = reinterpret<f64>(0x3FEEC709DC3A03FD), //  9.61796693925975554329e-01\n        cp_h    = reinterpret<f64>(0x3FEEC709E0000000), //  9.61796700954437255859e-01\n        cp_l    = reinterpret<f64>(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n        ivln2   = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n        ivln2_h = reinterpret<f64>(0x3FF7154760000000), //  1.44269502162933349609e+00\n        ivln2_l = reinterpret<f64>(0x3E54AE0BF85DDF44), //  1.92596299112661746887e-08\n        inv3    = reinterpret<f64>(0x3FD5555555555555); //  0.3333333333333333333333\n      let u_ = reinterpret<u64>(x);\n      let hx = <i32>(u_ >> 32);\n      let lx = <u32>u_;\n      u_ = reinterpret<u64>(y);\n      let hy = <i32>(u_ >> 32);\n      let ly = <u32>u_;\n      let ix = hx & 0x7FFFFFFF;\n      let iy = hy & 0x7FFFFFFF;\n      if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n      // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n      if ( // NaN if either arg is NaN\n        ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n        iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n      ) return x + y;\n      let yisint = 0, k: i32;\n      if (hx < 0) {\n        if (iy >= 0x43400000) yisint = 2;\n        else if (iy >= 0x3FF00000) {\n          k = (iy >> 20) - 0x3FF;\n          let offset = select<u32>(52, 20, k > 20) - k;\n          let Ly = select<u32>(ly, iy, k > 20);\n          let jj = Ly >> offset;\n          if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n        }\n      }\n      if (ly == 0) {\n        if (iy == 0x7FF00000) { // y is +-inf\n          if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n          else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n          else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n        }\n        if (iy == 0x3FF00000) {\n          if (hy >= 0) return x;\n          return 1 / x;\n        }\n        if (hy == 0x40000000) return x * x;\n        if (hy == 0x3FE00000) {\n          if (hx >= 0) return builtin_sqrt(x);\n        }\n      }\n      let ax = builtin_abs<f64>(x), z: f64;\n      if (lx == 0) {\n        if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n          z = ax;\n          if (hy < 0) z = 1.0 / z;\n          if (hx < 0) {\n            if (((ix - 0x3FF00000) | yisint) == 0) {\n              let d = z - z;\n              z = d / d;\n            } else if (yisint == 1) z = -z;\n          }\n          return z;\n        }\n      }\n      let s = 1.0;\n      if (hx < 0) {\n        if (yisint == 0) {\n          let d = x - x;\n          return d / d;\n        }\n        if (yisint == 1) s = -1.0;\n      }\n      let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n      let j: i32, n: i32;\n      if (iy > 0x41E00000) {\n        if (iy > 0x43F00000) {\n          if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n          if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n        }\n        if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n        if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n        t = ax - 1.0;\n        w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n        u = ivln2_h * t;\n        v = t * ivln2_l - w * ivln2;\n        t1 = u + v;\n        t1 = reinterpret<f64>(reinterpret<u64>(t1) & 0xFFFFFFFF00000000);\n        t2 = v - (t1 - u);\n      } else {\n        let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n        n = 0;\n        if (ix < 0x00100000) {\n          ax *= two53;\n          n -= 53;\n          ix = <u32>(reinterpret<u64>(ax) >> 32);\n        }\n        n += (ix >> 20) - 0x3FF;\n        j = ix & 0x000FFFFF;\n        ix = j | 0x3FF00000;\n        if (j <= 0x3988E) k = 0;\n        else if (j < 0xBB67A) k = 1;\n        else {\n          k = 0;\n          n += 1;\n          ix -= 0x00100000;\n        }\n        ax = reinterpret<f64>(reinterpret<u64>(ax) & 0xFFFFFFFF | (<u64>ix << 32));\n        let bp = select<f64>(1.5, 1.0, k); // k ? 1.5 : 1.0\n        u = ax - bp;\n        v = 1.0 / (ax + bp);\n        ss = u * v;\n        s_h = ss;\n        s_h = reinterpret<f64>(reinterpret<u64>(s_h) & 0xFFFFFFFF00000000);\n        t_h = reinterpret<f64>(<u64>(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n        t_l = ax - (t_h - bp);\n        s_l = v * ((u - s_h * t_h) - s_h * t_l);\n        s2 = ss * ss;\n        r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n        r += s_l * (s_h + ss);\n        s2 = s_h * s_h;\n        t_h = 3.0 + s2 + r;\n        t_h = reinterpret<f64>(reinterpret<u64>(t_h) & 0xFFFFFFFF00000000);\n        t_l = r - ((t_h - 3.0) - s2);\n        u = s_h * t_h;\n        v = s_l * t_h + t_l * ss;\n        p_h = u + v;\n        p_h = reinterpret<f64>(reinterpret<u64>(p_h) & 0xFFFFFFFF00000000);\n        p_l = v - (p_h - u);\n        let z_h = cp_h * p_h;\n        let dp_l = select<f64>(dp_l1, 0.0, k);\n        let z_l = cp_l * p_h + p_l * cp + dp_l;\n        t = <f64>n;\n        let dp_h = select<f64>(dp_h1, 0.0, k);\n        t1 = ((z_h + z_l) + dp_h) + t;\n        t1 = reinterpret<f64>(reinterpret<u64>(t1) & 0xFFFFFFFF00000000);\n        t2 = z_l - (((t1 - t) - dp_h) - z_h);\n      }\n      let y1 = y;\n      y1 = reinterpret<f64>(reinterpret<u64>(y1) & 0xFFFFFFFF00000000);\n      p_l = (y - y1) * t1 + y * t2;\n      p_h = y1 * t1;\n      z = p_l + p_h;\n      u_ = reinterpret<u64>(z);\n      j = <u32>(u_ >> 32);\n      let i = <i32>u_;\n      if (j >= 0x40900000) {\n        if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n        if (p_l + ovt > z - p_h) return s * huge * huge;\n      } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n        if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n        if (p_l <= z - p_h) return s * tiny * tiny;\n      }\n      i = j & 0x7FFFFFFF;\n      k = (i >> 20) - 0x3FF;\n      n = 0;\n      if (i > 0x3FE00000) {\n        n = j + (0x00100000 >> (k + 1));\n        k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n        t = 0.0;\n        t = reinterpret<f64>(<u64>(n & ~(0x000FFFFF >> k)) << 32);\n        n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n        if (j < 0) n = -n;\n        p_h -= t;\n      }\n      t = p_l + p_h;\n      t = reinterpret<f64>(reinterpret<u64>(t) & 0xFFFFFFFF00000000);\n      u = t * lg2_h;\n      v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n      z = u + v;\n      w = v - (z - u);\n      t = z * z;\n      t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n      r = (z * t1) / (t1 - 2.0) - (w + z * w);\n      z = 1.0 - (r - z);\n      j = <u32>(reinterpret<u64>(z) >> 32);\n      j += n << 20;\n      if ((j >> 20) <= 0) z = scalbn(z, n);\n      else z = reinterpret<f64>(reinterpret<u64>(z) & 0xFFFFFFFF | (<u64>j << 32));\n      return s * z;\n    }\n  }\n\n  export function seedRandom(value: i64): void {\n    random_seeded = true;\n    random_state0_64 = murmurHash3(value);\n    random_state1_64 = murmurHash3(~random_state0_64);\n    random_state0_32 = splitMix32(<u32>value);\n    random_state1_32 = splitMix32(random_state0_32);\n    assert(\n      random_state0_64 != 0 && random_state1_64 != 0 &&\n      random_state0_32 != 0 && random_state1_32 != 0\n    );\n  }\n\n  export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n    if (!random_seeded) seedRandom(reinterpret<i64>(seed()));\n    var s1 = random_state0_64;\n    var s0 = random_state1_64;\n    random_state0_64 = s0;\n    s1 ^= s1 << 23;\n    s1 ^= s1 >> 17;\n    s1 ^= s0;\n    s1 ^= s0 >> 26;\n    random_state1_64 = s1;\n    var r = (s0 >> 12) | 0x3FF0000000000000;\n    return reinterpret<f64>(r) - 1;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function round(x: f64): f64 {\n    return builtin_copysign<f64>(builtin_floor<f64>(x + 0.5), x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sign(x: f64): f64 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return builtin_abs(x) > 0 ? builtin_copysign<f64>(1, x) : x;\n    } else {\n      return x > 0 ? 1 : x < 0 ? -1 : x;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function signbit(x: f64): bool {\n    // In ECMAScript all NaN values are indistinguishable from each other\n    // so we need handle NaN and negative NaN in similar way\n    return <bool>(<i32>(reinterpret<u64>(x) >>> 63) & i32(x == x));\n  }\n\n  export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n    var u  = reinterpret<u64>(x);\n    var ix = <u32>(u >> 32);\n    var sign = ix >> 31;\n\n    ix &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ix <= 0x3FE921FB) {\n      if (ix < 0x3E500000) { // |x| < 2**-26\n        return x;\n      }\n      return sin_kern(x, 0.0, 0);\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7FF00000) return x - x;\n\n    // argument reduction needed\n    var n  = rempio2(x, u, sign);\n    var y0 = rempio2_y0;\n    var y1 = rempio2_y1;\n\n    x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n    return n & 2 ? -x : x;\n  }\n\n  export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n    var u = reinterpret<u64>(x) & 0x7FFFFFFFFFFFFFFF;\n    var absx = reinterpret<f64>(u);\n    var w = <u32>(u >> 32);\n    var t: f64;\n    var h = builtin_copysign(0.5, x);\n    if (w < 0x40862E42) {\n      t = expm1(absx);\n      if (w < 0x3FF00000) {\n        if (w < 0x3FF00000 - (26 << 20)) return x;\n        return h * (2 * t - t * t / (t + 1));\n      }\n      return h * (t + t / (t + 1));\n    }\n    t = 2 * h * expo2(absx);\n    return t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sqrt(x: f64): f64 {\n    return builtin_sqrt<f64>(x);\n  }\n\n  export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n    var u = reinterpret<u64>(x);\n    var ix = <i32>(u >> 32);\n    var sign = ix >>> 31;\n\n    ix &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ix <= 0x3FE921FB) {\n      if (ix < 0x3E400000) { // |x| < 2**-27\n        return x;\n      }\n      return tan_kern(x, 0.0, 1);\n    }\n\n    // tan(Inf or NaN) is NaN\n    if (ix >= 0x7FF00000) return x - x;\n\n    var n = rempio2(x, u, sign);\n    return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n  }\n\n  export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n    var u = reinterpret<u64>(x);\n    u &= 0x7FFFFFFFFFFFFFFF;\n    var y = reinterpret<f64>(u);\n    var w = <u32>(u >> 32);\n    var t: f64;\n    if (w > 0x3FE193EA) {\n      if (w > 0x40340000) {\n        t = 1 - 0 / y;\n      } else {\n        t = expm1(2 * y);\n        t = 1 - 2 / (t + 2);\n      }\n    } else if (w > 0x3FD058AE) {\n      t = expm1(2 * y);\n      t = t / (t + 2);\n    } else if (w >= 0x00100000) {\n      t = expm1(-2 * y);\n      t = -t / (t + 2);\n    } else t = y;\n    return builtin_copysign<f64>(t, x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function trunc(x: f64): f64 {\n    return builtin_trunc<f64>(x);\n  }\n\n  export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n    const\n      Ox1p53    = reinterpret<f64>(0x4340000000000000),\n      Ox1p1023  = reinterpret<f64>(0x7FE0000000000000),\n      Ox1p_1022 = reinterpret<f64>(0x0010000000000000);\n    var y = x;\n    if (n > 1023) {\n      y *= Ox1p1023;\n      n -= 1023;\n      if (n > 1023) {\n        y *= Ox1p1023;\n        n = builtin_min<i32>(n - 1023, 1023);\n      }\n    } else if (n < -1022) {\n      // make sure final n < -53 to avoid double\n      // rounding in the subnormal range\n      y *= Ox1p_1022 * Ox1p53;\n      n += 1022 - 53;\n      if (n < -1022) {\n        y *= Ox1p_1022 * Ox1p53;\n        n = builtin_max<i32>(n + 1022 - 53, -1022);\n      }\n    }\n    return y * reinterpret<f64>(<u64>(0x3FF + n) << 52);\n  }\n\n  export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n    var ux = reinterpret<u64>(x);\n    var uy = reinterpret<u64>(y);\n    var ex = <i64>(ux >> 52 & 0x7FF);\n    var ey = <i64>(uy >> 52 & 0x7FF);\n    var sx = ux >> 63;\n    var uy1 = uy << 1;\n    if (uy1 == 0 || ex == 0x7FF || isNaN<f64>(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    var ux1 = ux << 1;\n    if (ux1 <= uy1) {\n      if (ux1 == uy1) return 0 * x;\n      return x;\n    }\n    if (!ex) {\n      ex -= builtin_clz<i64>(ux << 12);\n      ux <<= -ex + 1;\n    } else {\n      ux &= <u64>-1 >> 12;\n      ux |= 1 << 52;\n    }\n    if (!ey) {\n      ey -= builtin_clz<i64>(uy << 12);\n      uy <<= -ey + 1;\n    } else {\n      uy &= <u64>-1 >> 12;\n      uy |= 1 << 52;\n    }\n    while (ex > ey) {\n      if (ux >= uy) {\n        if (ux == uy) return 0 * x;\n        ux -= uy;\n      }\n      ux <<= 1;\n      --ex;\n    }\n    if (ux >= uy) {\n      if (ux == uy) return 0 * x;\n      ux -= uy;\n    }\n    // for (; !(ux >> 52); ux <<= 1) --ex;\n    var shift = builtin_clz<i64>(ux << 11);\n    ex -= shift;\n    ux <<= shift;\n    if (ex > 0) {\n      ux -= 1 << 52;\n      ux |= ex << 52;\n    } else {\n      ux >>= -ex + 1;\n    }\n    ux |= sx << 63;\n    return reinterpret<f64>(ux);\n  }\n\n  export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n    var ux = reinterpret<u64>(x);\n    var uy = reinterpret<u64>(y);\n    var ex = <i64>(ux >> 52 & 0x7FF);\n    var ey = <i64>(uy >> 52 & 0x7FF);\n    var sx = <i32>(ux >> 63);\n    if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    if (ux << 1 == 0) return x;\n    var uxi = ux;\n    if (!ex) {\n      ex -= builtin_clz<i64>(uxi << 12);\n      uxi <<= -ex + 1;\n    } else {\n      uxi &= <u64>-1 >> 12;\n      uxi |= 1 << 52;\n    }\n    if (!ey) {\n      ey -= builtin_clz<i64>(uy << 12);\n      uy <<= -ey + 1;\n    } else {\n      uy &= <u64>-1 >> 12;\n      uy |= 1 << 52;\n    }\n    var q: u32 = 0;\n    do {\n      if (ex < ey) {\n        if (ex + 1 == ey) break; // goto end\n        return x;\n      }\n      while (ex > ey) {\n        if (uxi >= uy) {\n          uxi -= uy;\n          ++q;\n        }\n        uxi <<= 1;\n        q <<= 1;\n        --ex;\n      }\n      if (uxi >= uy) {\n        uxi -= uy;\n        ++q;\n      }\n      if (uxi == 0) ex = -60;\n      else {\n        let shift = builtin_clz<i64>(uxi << 11);\n        ex -= shift;\n        uxi <<= shift;\n      }\n      break;\n    } while (false);\n    // end:\n    if (ex > 0) {\n      uxi -= 1 << 52;\n      uxi |= ex << 52;\n    } else {\n      uxi >>= -ex + 1;\n    }\n    x = reinterpret<f64>(uxi);\n    y = builtin_abs<f64>(y);\n    var x2 = x + x;\n    if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && <bool>(q & 1))))) {\n      x -= y;\n      // ++q;\n    }\n    return sx ? -x : x;\n  }\n\n  export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n    var u = reinterpret<u64>(x);\n    var ix = <u32>(u >> 32);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3FE921FB) {  // |x| ~<= π/4\n      if (ix < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n        sincos_sin = x;\n        sincos_cos = 1;\n        return;\n      }\n      sincos_sin = sin_kern(x, 0, 0);\n      sincos_cos = cos_kern(x, 0);\n      return;\n    }\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) {\n      let xx = x - x;\n      sincos_sin = xx;\n      sincos_cos = xx;\n      return;\n    }\n    // general argument reduction needed\n    var n = rempio2(x, u, sign);\n    var y0 = rempio2_y0;\n    var y1 = rempio2_y1;\n    var s = sin_kern(y0, y1, 1);\n    var c = cos_kern(y0, y1);\n    var sin = s, cos = c;\n    if (n & 1) {\n      sin =  c;\n      cos = -s;\n    }\n    if (n & 2) {\n      sin = -sin;\n      cos = -cos;\n    }\n    sincos_sin = sin;\n    sincos_cos = cos;\n  }\n}\n\n// @ts-ignore: decorator\n@lazy var rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data<u64>([\n  0xA2F9836E4E441529,\n  0xFC2757D1F534DDC0,\n  0xDB6295993C439041,\n  0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n  const                    // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n    pS0 = reinterpret<f32>(0x3E2AAA75), //  1.6666586697e-01f\n    pS1 = reinterpret<f32>(0xBD2F13BA), // -4.2743422091e-02f\n    pS2 = reinterpret<f32>(0xBC0DD36B), // -8.6563630030e-03f\n    qS1 = reinterpret<f32>(0xBF34E5AE); // -7.0662963390e-01f\n  var p = z * (pS0 + z * (pS1 + z * pS2));\n  var q: f32 = 1 + z * qS1;\n  return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n  const                                // see: musl/src/math/__expo2f.c\n    k    = <u32>235,\n    kln2 = reinterpret<f32>(0x4322E3BC); // 0x1.45c778p+7f\n  var scale = reinterpret<f32>(<u32>(0x7F + (k >> 1)) << 23);\n  return NativeMathf.exp(x - kln2) * scale * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n  const coeff = reinterpret<f64>(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n  var offset = (u >> 23) - 152;\n  var shift  = <u64>(offset & 63);\n  var tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n  var b0 = load<u64>(tblPtr, 0 << 3);\n  var b1 = load<u64>(tblPtr, 1 << 3);\n  var lo: u64;\n\n  if (shift > 32) {\n    let b2 = load<u64>(tblPtr, 2 << 3);\n    lo  = b2 >> (96 - shift);\n    lo |= b1 << (shift - 32);\n  } else {\n    lo = b1 >> (32 - shift);\n  }\n\n  var hi = (b1 >> (64 - shift)) | (b0 << shift);\n  var mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n  var product = mantissa * hi + (mantissa * lo >> 32);\n  var r: i64 = product << 2;\n  var q = <i32>((product >> 62) + (r >>> 63));\n  rempio2f_y = copysign<f64>(coeff, x) * <f64>r;\n  return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n  const pi2hi = reinterpret<f64>(0x3FF921FB50000000); // 1.57079631090164184570\n  const pi2lo = reinterpret<f64>(0x3E5110B4611A6263); // 1.58932547735281966916e-8\n  const _2_pi = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n  if (u < 0x4DC90FDB) { // π * 0x1p28\n    let q = nearest(x * _2_pi);\n    rempio2f_y = x - q * pi2hi - q * pi2lo;\n    return <i32>q;\n  }\n\n  var q = pio2f_large_quot(x, u);\n  return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n  const S1 = reinterpret<f64>(0xBFC5555554CBAC77); // -0x15555554cbac77.0p-55\n  const S2 = reinterpret<f64>(0x3F811110896EFBB2); //  0x111110896efbb2.0p-59\n  const S3 = reinterpret<f64>(0xBF2A00F9E2CAE774); // -0x1a00f9e2cae774.0p-65\n  const S4 = reinterpret<f64>(0x3EC6CD878C3B46A7); //  0x16cd878c3b46a7.0p-71\n\n  var z = x * x;\n  var w = z * z;\n  var r = S3 + z * S4;\n  var s = z * x;\n  return <f32>((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n  const C0 = reinterpret<f64>(0xBFDFFFFFFD0C5E81); // -0x1ffffffd0c5e81.0p-54\n  const C1 = reinterpret<f64>(0x3FA55553E1053A42); //  0x155553e1053a42.0p-57\n  const C2 = reinterpret<f64>(0xBF56C087E80F1E27); // -0x16c087e80f1e27.0p-62\n  const C3 = reinterpret<f64>(0x3EF99342E0EE5069); //  0x199342e0ee5069.0p-68\n\n  var z = x * x;\n  var w = z * z;\n  var r = C2 + z * C3;\n  return <f32>(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n\n  const T0 = reinterpret<f64>(0x3FD5554D3418C99F); // 0x15554d3418c99f.0p-54\n  const T1 = reinterpret<f64>(0x3FC112FD38999F72); // 0x1112fd38999f72.0p-55\n  const T2 = reinterpret<f64>(0x3FAB54C91D865AFE); // 0x1b54c91d865afe.0p-57\n  const T3 = reinterpret<f64>(0x3F991DF3908C33CE); // 0x191df3908c33ce.0p-58\n  const T4 = reinterpret<f64>(0x3F685DADFCECF44E); // 0x185dadfcecf44e.0p-61\n  const T5 = reinterpret<f64>(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n  var z = x * x;\n  var r = T4 + z * T5;\n  var t = T2 + z * T3;\n  var w = z * z;\n  var s = z * x;\n  var u = T0 + z * T1;\n\n  r = (x + s * u) + (s * w) * (t + w * r);\n  return <f32>(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n  const\n    log2e = reinterpret<f64>(0x3FF71547652B82FE), // 1.44269504088896340736\n    c0 = reinterpret<f64>(0x3FD555554FD9CAEF),    // 0.33333332822728226129\n    c1 = reinterpret<f64>(0x3FC999A7A8AF4132),    // 0.20000167595436263505\n    c2 = reinterpret<f64>(0x3FC2438D79437030),    // 0.14268654271188685375\n    c3 = reinterpret<f64>(0x3FBE2F663B001C97);    // 0.11791075649681414150\n\n  var i = reinterpret<i64>(x);\n  var exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n  x = reinterpret<f64>(i - (exponent << 52));\n  x = (x - 1) / (x + 1);\n  var xx = x * x;\n  var y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n  return (2 * log2e) * y + <f64>exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n  const\n    c0 = reinterpret<f64>(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n    c1 = reinterpret<f64>(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n    c2 = reinterpret<f64>(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n    c3 = reinterpret<f64>(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n    c4 = reinterpret<f64>(0x3F55F0896145A89F), // 1.339086685300950937e-3\n    c5 = reinterpret<f64>(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n  if (x < -1022) return 0;\n  if (x >= 1024) return Infinity;\n\n  var n = nearest(x);\n  x -= n;\n  var xx = x * x;\n  var y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n  return reinterpret<f64>(reinterpret<i64>(y) + (<i64>n << 52));\n}\n\nexport namespace NativeMathf {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const E       = <f32>NativeMath.E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN2     = <f32>NativeMath.LN2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN10    = <f32>NativeMath.LN10;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG2E   = <f32>NativeMath.LOG2E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG10E  = <f32>NativeMath.LOG10E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const PI      = <f32>NativeMath.PI;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT1_2 = <f32>NativeMath.SQRT1_2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT2   = <f32>NativeMath.SQRT2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export var sincos_sin: f32 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export var sincos_cos: f32 = 0;\n\n  // @ts-ignore: decorator\n  @inline\n  export function abs(x: f32): f32 {\n    return builtin_abs<f32>(x);\n  }\n\n  export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f32>(0x3FC90FDA), // 1.5707962513e+00f\n      pio2_lo   = reinterpret<f32>(0x33A22168), // 7.5497894159e-08f\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n    var hx = reinterpret<u32>(x);\n    var ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3F800000) {\n      if (ix == 0x3F800000) {\n        if (hx >> 31) return 2 * pio2_hi + Ox1p_120f;\n        return 0;\n      }\n      return 0 / (x - x);\n    }\n    if (ix < 0x3F000000) {\n      if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n      return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n    }\n    var z: f32, w: f32, s: f32;\n    if (hx >> 31) {\n      // z = (1 + x) * 0.5;\n      z = 0.5 + x * 0.5;\n      s = builtin_sqrt<f32>(z);\n      w = Rf(z) * s - pio2_lo;\n      return 2 * (pio2_hi - (s + w));\n    }\n    // z = (1 - x) * 0.5;\n    z = 0.5 - x * 0.5;\n    s = builtin_sqrt<f32>(z);\n    hx = reinterpret<u32>(s);\n    var df = reinterpret<f32>(hx & 0xFFFFF000);\n    var c = (z - df * df) / (s + df);\n    w = Rf(z) * s + c;\n    return 2 * (df + w);\n  }\n\n  export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n    const s = reinterpret<f32>(0x3F317218); // 0.693147180559945309417232121458176568f\n    var u = reinterpret<u32>(x);\n    var a = u & 0x7FFFFFFF;\n    if (a < 0x3F800000 + (1 << 23)) {\n      let xm1 = x - 1;\n      return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n    }\n    if (a < 0x3F800000 + (12 << 23)) return log(2 * x - 1 / (x + builtin_sqrt<f32>(x * x - 1)));\n    return log(x) + s;\n  }\n\n  export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2      = reinterpret<f32>(0x3FC90FDB), // 1.570796326794896558e+00f\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n    var sx = x;\n    var hx = reinterpret<u32>(x) & 0x7FFFFFFF;\n    if (hx >= 0x3F800000) {\n      if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n      return 0 / (x - x);\n    }\n    if (hx < 0x3F000000) {\n      if (hx < 0x39800000 && hx >= 0x00800000) return x;\n      return x + x * Rf(x * x);\n    }\n    // var z: f32 = (1 - builtin_abs<f32>(x)) * 0.5;\n    var z: f32 = 0.5 - builtin_abs<f32>(x) * 0.5;\n    var s = builtin_sqrt<f64>(z); // sic\n    x = <f32>(pio2 - 2 * (s + s * Rf(z)));\n    return builtin_copysign(x, sx);\n  }\n\n  export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n    const c = reinterpret<f32>(0x3F317218); // 0.693147180559945309417232121458176568f\n    var u = reinterpret<u32>(x) & 0x7FFFFFFF;\n    var y = reinterpret<f32>(u);\n    if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n    else if (u >= 0x3F800000 + (1 << 23))  y =   log(2 * y + 1 / (builtin_sqrt<f32>(y * y + 1) + y));\n    else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt<f32>(y * y + 1) + 1));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n    const\n      atanhi0   = reinterpret<f32>(0x3EED6338), //  4.6364760399e-01f\n      atanhi1   = reinterpret<f32>(0x3F490FDA), //  7.8539812565e-01f\n      atanhi2   = reinterpret<f32>(0x3F7B985E), //  9.8279368877e-01f\n      atanhi3   = reinterpret<f32>(0x3FC90FDA), //  1.5707962513e+00f\n      atanlo0   = reinterpret<f32>(0x31AC3769), //  5.0121582440e-09f\n      atanlo1   = reinterpret<f32>(0x33222168), //  3.7748947079e-08f\n      atanlo2   = reinterpret<f32>(0x33140FB4), //  3.4473217170e-08f\n      atanlo3   = reinterpret<f32>(0x33A22168), //  7.5497894159e-08f\n      aT0       = reinterpret<f32>(0x3EAAAAA9), //  3.3333328366e-01f\n      aT1       = reinterpret<f32>(0xBE4CCA98), // -1.9999158382e-01f\n      aT2       = reinterpret<f32>(0x3E11F50D), //  1.4253635705e-01f\n      aT3       = reinterpret<f32>(0xBDDA1247), // -1.0648017377e-01f\n      aT4       = reinterpret<f32>(0x3D7CAC25), //  6.1687607318e-02f\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n    var ix = reinterpret<u32>(x);\n    var sx = x;\n    ix &= 0x7FFFFFFF;\n    var z: f32;\n    if (ix >= 0x4C800000) {\n      if (isNaN(x)) return x;\n      z = atanhi3 + Ox1p_120f;\n      return builtin_copysign(z, sx);\n    }\n    var id: i32;\n    if (ix < 0x3EE00000) {\n      if (ix < 0x39800000) return x;\n      id = -1;\n    } else {\n      x = builtin_abs<f32>(x);\n      if (ix < 0x3F980000) {\n        if (ix < 0x3F300000) {\n          id = 0;\n          x = (2.0 * x - 1.0) / (2.0 + x);\n        } else {\n          id = 1;\n          x = (x - 1.0) / (x + 1.0);\n        }\n      } else {\n        if (ix < 0x401C0000) {\n          id = 2;\n          x = (x - 1.5) / (1.0 + 1.5 * x);\n        } else {\n          id = 3;\n          x = -1.0 / x;\n        }\n      }\n    }\n    z = x * x;\n    var w = z * z;\n    var s1 = z * (aT0 + w * (aT2 + w * aT4));\n    var s2 = w * (aT1 + w * aT3);\n    var s3 = x * (s1 + s2);\n    if (id < 0) return x - s3;\n    switch (id) {\n      case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n      case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n      case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n      case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n      default: unreachable();\n    }\n    return builtin_copysign(z, sx);\n  }\n\n  export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n    var u = reinterpret<u32>(x);\n    var y = builtin_abs(x);\n    if (u < 0x3F800000 - (1 << 23)) {\n      if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n    } else y = 0.5 * log1p(2 * (y / (1 - y)));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n    const\n      pi    = reinterpret<f32>(0x40490FDB), //  3.1415927410e+00f\n      pi_lo = reinterpret<f32>(0xB3BBBD2E); // -8.7422776573e-08f\n    if (isNaN(x) || isNaN(y)) return x + y;\n    var ix = reinterpret<u32>(x);\n    var iy = reinterpret<u32>(y);\n    if (ix == 0x3F800000) return atan(y);\n    var m = <u32>(((iy >> 31) & 1) | ((ix >> 30) & 2));\n    ix &= 0x7FFFFFFF;\n    iy &= 0x7FFFFFFF;\n    if (iy == 0) {\n      switch (m) {\n        case 0:\n        case 1: return  y;\n        case 2: return  pi;\n        case 3: return -pi;\n      }\n    }\n    if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n    if (ix == 0x7F800000) {\n      if (iy == 0x7F800000) {\n        let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n        return m & 1 ? -t : t;\n      } else {\n        let t: f32 = m & 2 ? pi : 0.0;\n        return m & 1 ? -t : t;\n      }\n    }\n    if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n    var z: f32;\n    if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n    else z = atan(builtin_abs<f32>(y / x));\n    switch (m) {\n      case 0: return  z;\n      case 1: return -z;\n      case 2: return pi - (z - pi_lo);\n      case 3: return (z - pi_lo) - pi;\n    }\n    unreachable();\n    return 0;\n  }\n\n  export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n    const\n      B1      = <u32>709958130,\n      B2      = <u32>642849266,\n      Ox1p24f = reinterpret<f32>(0x4B800000);\n    var u = reinterpret<u32>(x);\n    var hx = u & 0x7FFFFFFF;\n    if (hx >= 0x7F800000) return x + x;\n    if (hx < 0x00800000) {\n      if (hx == 0) return x;\n      u = reinterpret<u32>(x * Ox1p24f);\n      hx = u & 0x7FFFFFFF;\n      hx = hx / 3 + B2;\n    } else {\n      hx = hx / 3 + B1;\n    }\n    u &= 0x80000000;\n    u |= hx;\n    var t = <f64>reinterpret<f32>(u);\n    var r = t * t * t;\n    t = t * (<f64>x + x + r) / (x + r + r);\n    r = t * t * t;\n    t = t * (<f64>x + x + r) / (x + r + r);\n    return <f32>t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function ceil(x: f32): f32 {\n    return builtin_ceil<f32>(x);\n  }\n\n  export function clz32(x: f32): f32 {\n    if (!isFinite(x)) return 32;\n    return <f32>builtin_clz(dtoi32(x));\n  }\n\n  export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n    const c1pio2 = reinterpret<f64>(0x3FF921FB54442D18); // M_PI_2 * 1\n    const c2pio2 = reinterpret<f64>(0x400921FB54442D18); // M_PI_2 * 2\n    const c3pio2 = reinterpret<f64>(0x4012D97C7F3321D2); // M_PI_2 * 3\n    const c4pio2 = reinterpret<f64>(0x401921FB54442D18); // M_PI_2 * 4\n\n    var ix = reinterpret<u32>(x);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ix < 0x39800000) { // |x| < 2**-12\n        // raise inexact if x != 0\n        return 1;\n      }\n      return cos_kernf(x);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ix <= 0x407B53D1) {  // |x| ~<= 5π/4\n        if (ix > 0x4016CBE3) { // |x|  ~> 3π/4\n          return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n        } else {\n          return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n        }\n      }\n      if (ix <= 0x40E231D5) {  // |x| ~<= 9π/4\n        if (ix > 0x40AFEDDF) { // |x|  ~> 7π/4\n          return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n        } else {\n          return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n        }\n      }\n    }\n\n    // cos(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) return x - x;\n\n    // general argument reduction needed\n    var n = rempio2f(x, ix, sign);\n    var y = rempio2f_y;\n\n    var t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n    return (n + 1) & 2 ? -t : t;\n  }\n\n  export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n    var u = reinterpret<u32>(x);\n    u &= 0x7FFFFFFF;\n    x = reinterpret<f32>(u);\n    if (u < 0x3F317217) {\n      if (u < 0x3F800000 - (12 << 23)) return 1;\n      let t = expm1(x);\n      // return 1 + t * t / (2 * (1 + t));\n      return 1 + t * t / (2 + 2 * t);\n    }\n    if (u < 0x42B17217) {\n      let t = exp(x);\n      // return 0.5 * (t + 1 / t);\n      return 0.5 * t + 0.5 / t;\n    }\n    return expo2f(x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function floor(x: f32): f32 {\n    return builtin_floor<f32>(x);\n  }\n\n  export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return expf_lut(x);\n    } else {\n      const\n        ln2hi    = reinterpret<f32>(0x3F317200), //  6.9314575195e-1f\n        ln2lo    = reinterpret<f32>(0x35BFBE8E), //  1.4286067653e-6f\n        invln2   = reinterpret<f32>(0x3FB8AA3B), //  1.4426950216e+0f\n        P1       = reinterpret<f32>(0x3E2AAA8F), //  1.6666625440e-1f\n        P2       = reinterpret<f32>(0xBB355215), // -2.7667332906e-3f\n        Ox1p127f = reinterpret<f32>(0x7F000000);\n      let hx = reinterpret<u32>(x);\n      let sign_ = <i32>(hx >> 31);\n      hx &= 0x7FFFFFFF;\n      if (hx >= 0x42AEAC50) {\n        if (hx > 0x7F800000) return x; // NaN\n        if (hx >= 0x42B17218) {\n          if (!sign_) return x * Ox1p127f;\n          else if (hx >= 0x42CFF1B5) return 0;\n        }\n      }\n      let hi: f32, lo: f32;\n      let k: i32;\n      if (hx > 0x3EB17218) {\n        if (hx > 0x3F851592) {\n          k = <i32>(invln2 * x + builtin_copysign<f32>(0.5, x));\n        } else {\n          k = 1 - (sign_ << 1);\n        }\n        hi = x - <f32>k * ln2hi;\n        lo = <f32>k * ln2lo;\n        x = hi - lo;\n      } else if (hx > 0x39000000) {\n        k = 0;\n        hi = x;\n        lo = 0;\n      } else {\n        return 1 + x;\n      }\n      let xx = x * x;\n      let c = x - xx * (P1 + xx * P2);\n      let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n      return k == 0 ? y : scalbn(y, k);\n    }\n  }\n\n  export function exp2(x: f32): f32 {\n    return exp2f_lut(x);\n  }\n\n  export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n    const\n      o_threshold = reinterpret<f32>(0x42B17180), //  8.8721679688e+01f\n      ln2_hi      = reinterpret<f32>(0x3F317180), //  6.9313812256e-01f\n      ln2_lo      = reinterpret<f32>(0x3717F7D1), //  9.0580006145e-06f\n      invln2      = reinterpret<f32>(0x3FB8AA3B), //  1.4426950216e+00f\n      Q1          = reinterpret<f32>(0xBD088868), // -3.3333212137e-02f\n      Q2          = reinterpret<f32>(0x3ACF3010), //  1.5807170421e-03f\n      Ox1p127f    = reinterpret<f32>(0x7F000000);\n    var u = reinterpret<u32>(x);\n    var hx = u & 0x7FFFFFFF;\n    var sign_ = <i32>(u >> 31);\n    if (hx >= 0x4195B844) {\n      if (hx > 0x7F800000) return x;\n      if (sign_) return -1;\n      if (x > o_threshold) {\n        x *= Ox1p127f;\n        return x;\n      }\n    }\n    var c: f32 = 0.0, t: f32, k: i32;\n    if (hx > 0x3EB17218) {\n      k = select<i32>(\n        1 - (sign_ << 1),\n        <i32>(invln2 * x + builtin_copysign<f32>(0.5, x)),\n        hx < 0x3F851592\n      );\n      t = <f32>k;\n      let hi = x - t * ln2_hi;\n      let lo = t * ln2_lo;\n      x = hi - lo;\n      c = (hi - x) - lo;\n    } else if (hx < 0x33000000) {\n      return x;\n    } else k = 0;\n    var hfx: f32 = 0.5 * x;\n    var hxs: f32 = x * hfx;\n    var r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n    t  = 3.0 - r1 * hfx;\n    var e = hxs * ((r1 - t) / (6.0 - x * t));\n    if (k == 0) return x - (x * e - hxs);\n    e  = x * (e - c) - c;\n    e -= hxs;\n    if (k == -1) return 0.5 * (x - e) - 0.5;\n    if (k == 1) {\n      if (x < -0.25) return -2.0 * (e - (x + 0.5));\n      return 1.0 + 2.0 * (x - e);\n    }\n    u = (0x7F + k) << 23;\n    var twopk = reinterpret<f32>(u);\n    var y: f32;\n    if (k < 0 || k > 56) {\n      y = x - e + 1.0;\n      if (k == 128) y = y * 2.0 * Ox1p127f;\n      else y = y * twopk;\n      return y - 1.0;\n    }\n    u = (0x7F - k) << 23;\n    y = reinterpret<f32>(u);\n    if (k < 20) y = (1 - y) - e;\n    else y = 1 - (e + y);\n    return (x + y) * twopk;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function fround(x: f32): f32 {\n    return x;\n  }\n\n  export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n    const\n      Ox1p90f  = reinterpret<f32>(0x6C800000),\n      Ox1p_90f = reinterpret<f32>(0x12800000);\n    var ux = reinterpret<u32>(x);\n    var uy = reinterpret<u32>(y);\n    ux &= 0x7FFFFFFF;\n    uy &= 0x7FFFFFFF;\n    if (ux < uy) {\n      let ut = ux;\n      ux = uy;\n      uy = ut;\n    }\n    x = reinterpret<f32>(ux);\n    y = reinterpret<f32>(uy);\n    if (uy == 0xFF << 23) return y;\n    if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n    var z: f32 = 1;\n    if (ux >= (0x7F + 60) << 23) {\n      z  = Ox1p90f;\n      x *= Ox1p_90f;\n      y *= Ox1p_90f;\n    } else if (uy < (0x7F - 60) << 23) {\n      z  = Ox1p_90f;\n      x *= Ox1p90f;\n      y *= Ox1p90f;\n    }\n    return z * builtin_sqrt<f32>(<f32>(<f64>x * x + <f64>y * y));\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function imul(x: f32, y: f32): f32 {\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    if (!isFinite(x + y)) return 0;\n    return <f32>(dtoi32(x) * dtoi32(y));\n  }\n\n  export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return logf_lut(x);\n    } else {\n      const\n        ln2_hi  = reinterpret<f32>(0x3F317180), // 6.9313812256e-01f\n        ln2_lo  = reinterpret<f32>(0x3717F7D1), // 9.0580006145e-06f\n        Lg1     = reinterpret<f32>(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n        Lg2     = reinterpret<f32>(0x3ECCCE13), // 0xccce13.0p-25f\n        Lg3     = reinterpret<f32>(0x3E91E9EE), // 0x91e9ee.0p-25f\n        Lg4     = reinterpret<f32>(0x3E789E26), // 0xf89e26.0p-26f\n        Ox1p25f = reinterpret<f32>(0x4C000000);\n      let u = reinterpret<u32>(x);\n      let k = 0;\n      if (u < 0x00800000 || <bool>(u >> 31)) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (u >> 31) return (x - x) / 0;\n        k -= 25;\n        x *= Ox1p25f;\n        u = reinterpret<u32>(x);\n      } else if (u >= 0x7F800000) {\n        return x;\n      } else if (u == 0x3F800000) {\n        return 0;\n      }\n      u += 0x3F800000 - 0x3F3504F3;\n      k += <u32>(<i32>u >> 23) - 0x7F;\n      u = (u & 0x007FFFFF) + 0x3F3504F3;\n      x = reinterpret<f32>(u);\n      let f = x - 1.0;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * Lg4);\n      let t2 = z * (Lg1 + w * Lg3);\n      let r = t2 + t1;\n      let hfsq = <f32>0.5 * f * f;\n      let dk = <f32>k;\n      return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n    }\n  }\n\n  export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n    const\n      ivln10hi  = reinterpret<f32>(0x3EDE6000), //  4.3432617188e-01f\n      ivln10lo  = reinterpret<f32>(0xB804EAD9), // -3.1689971365e-05f\n      log10_2hi = reinterpret<f32>(0x3E9A2080), //  3.0102920532e-01f\n      log10_2lo = reinterpret<f32>(0x355427DB), //  7.9034151668e-07f\n      Lg1       = reinterpret<f32>(0x3F2AAAAA), //  0xaaaaaa.0p-24f, 0.66666662693f\n      Lg2       = reinterpret<f32>(0x3ECCCE13), //  0xccce13.0p-25f, 0.40000972152f\n      Lg3       = reinterpret<f32>(0x3E91E9EE), //  0x91e9ee.0p-25f, 0.28498786688f\n      Lg4       = reinterpret<f32>(0x3E789E26), //  0xf89e26.0p-26f, 0.24279078841f\n      Ox1p25f   = reinterpret<f32>(0x4C000000);\n    var ix = reinterpret<u32>(x);\n    var k = 0;\n    if (ix < 0x00800000 || <bool>(ix >> 31)) {\n      if (ix << 1 == 0) return -1 / (x * x);\n      if (ix >> 31) return (x - x) / 0.0;\n      k -= 25;\n      x *= Ox1p25f;\n      ix = reinterpret<u32>(x);\n    } else if (ix >= 0x7F800000) {\n      return x;\n    } else if (ix == 0x3F800000) {\n      return 0;\n    }\n    ix += 0x3F800000 - 0x3F3504F3;\n    k += <i32>(ix >> 23) - 0x7F;\n    ix = (ix & 0x007FFFFF) + 0x3F3504F3;\n    x = reinterpret<f32>(ix);\n    var f = x - 1.0;\n    var s = f / (2.0 + f);\n    var z = s * s;\n    var w = z * z;\n    var t1 = w * (Lg2 + w * Lg4);\n    var t2 = z * (Lg1 + w * Lg3);\n    var r = t2 + t1;\n    var hfsq: f32 = 0.5 * f * f;\n    var hi = f - hfsq;\n    ix = reinterpret<u32>(hi);\n    ix &= 0xFFFFF000;\n    hi = reinterpret<f32>(ix);\n    var lo = f - hi - hfsq + s * (hfsq + r);\n    var dk = <f32>k;\n    return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n  }\n\n  export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi = reinterpret<f32>(0x3F317180), // 6.9313812256e-01\n      ln2_lo = reinterpret<f32>(0x3717F7D1), // 9.0580006145e-06\n      Lg1    = reinterpret<f32>(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n      Lg2    = reinterpret<f32>(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n      Lg3    = reinterpret<f32>(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n      Lg4    = reinterpret<f32>(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n    var ix = reinterpret<u32>(x);\n    var c: f32 = 0, f: f32 = 0;\n    var k: i32 = 1;\n    if (ix < 0x3ED413D0 || <bool>(ix >> 31)) {\n      if (ix >= 0xBF800000) {\n        if (x == -1) return x / 0.0;\n        return (x - x) / 0.0;\n      }\n      if (ix << 1 < 0x33800000 << 1) return x;\n      if (ix <= 0xBE95F619) {\n        k = 0;\n        c = 0;\n        f = x;\n      }\n    } else if (ix >= 0x7F800000) return x;\n    if (k) {\n      let uf: f32 = 1 + x;\n      let iu = reinterpret<u32>(uf);\n      iu += 0x3F800000 - 0x3F3504F3;\n      k = <i32>(iu >> 23) - 0x7F;\n      if (k < 25) {\n        c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n        c /= uf;\n      } else c = 0;\n      iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n      f = reinterpret<f32>(iu) - 1;\n    }\n    var s = f / (2.0 + f);\n    var z = s * s;\n    var w = z * z;\n    var t1 = w * (Lg2 + w * Lg4);\n    var t2 = z * (Lg1 + w * Lg3);\n    var r = t2 + t1;\n    var hfsq: f32 = 0.5 * f * f;\n    var dk = <f32>k;\n    return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n  }\n\n  export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log2f_lut(x);\n    } else {\n      const\n        ivln2hi = reinterpret<f32>(0x3FB8B000), //  1.4428710938e+00f\n        ivln2lo = reinterpret<f32>(0xB9389AD4), // -1.7605285393e-04\n        Lg1     = reinterpret<f32>(0x3F2AAAAA), //  0xaaaaaa.0p-24f, 0.66666662693f\n        Lg2     = reinterpret<f32>(0x3ECCCE13), //  0xccce13.0p-25f, 0.40000972152f\n        Lg3     = reinterpret<f32>(0x3E91E9EE), //  0x91e9ee.0p-25f, 0.28498786688f\n        Lg4     = reinterpret<f32>(0x3E789E26), //  0xf89e26.0p-26f, 0.24279078841f\n        Ox1p25f = reinterpret<f32>(0x4C000000);\n      let ix = reinterpret<u32>(x);\n      let k: i32 = 0;\n      if (ix < 0x00800000 || <bool>(ix >> 31)) {\n        if (ix << 1 == 0) return -1 / (x * x);\n        if (ix >> 31) return (x - x) / 0.0;\n        k -= 25;\n        x *= Ox1p25f;\n        ix = reinterpret<u32>(x);\n      } else if (ix >= 0x7F800000) {\n        return x;\n      } else if (ix == 0x3F800000) {\n        return 0;\n      }\n      ix += 0x3F800000 - 0x3F3504F3;\n      k += <i32>(ix >> 23) - 0x7F;\n      ix = (ix & 0x007FFFFF) + 0x3F3504F3;\n      x = reinterpret<f32>(ix);\n      let f = x - 1.0;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * Lg4);\n      let t2 = z * (Lg1 + w * Lg3);\n      let r = t2 + t1;\n      let hfsq: f32 = 0.5 * f * f;\n      let hi = f - hfsq;\n      let u = reinterpret<u32>(hi);\n      u &= 0xFFFFF000;\n      hi = reinterpret<f32>(u);\n      let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n      let dk = <f32>k;\n      return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function max(value1: f32, value2: f32): f32 {\n    return builtin_max<f32>(value1, value2);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function min(value1: f32, value2: f32): f32 {\n    return builtin_min<f32>(value1, value2);\n  }\n\n  export function pow(x: f32, y: f32): f32 {\n    // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n    if (builtin_abs<f32>(y) <= 2) {\n      if (y == 2.0) return x * x;\n      if (y == 0.5) {\n        return select<f32>(\n          builtin_abs<f32>(builtin_sqrt<f32>(x)),\n          Infinity,\n          x != -Infinity\n        );\n      }\n      if (y == -1.0) return 1 / x;\n      if (y == 1.0) return x;\n      if (y == 0.0) return 1.0;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      // see: musl/src/math/powf.c\n      return powf_lut(x, y);\n    } else {\n      // based on:  jdh8/metallic/src/math/float/powf.c\n      if (y == 0) return 1;\n      // @ts-ignore: cast\n      if (isNaN(x) | isNaN(y)) {\n        return NaN;\n      }\n      let sign: u32 = 0;\n      let uy = reinterpret<u32>(y);\n      let ux = reinterpret<u32>(x);\n      let sx = ux >> 31;\n      ux &= 0x7FFFFFFF;\n      if (sx && nearest(y) == y) {\n        x = -x;\n        sx = 0;\n        sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n      }\n      let m: u32;\n      if (ux == 0x3F800000) { // x == 1\n        m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n      } else if (ux == 0) {\n        m = uy >> 31 ? 0x7F800000 : 0;\n      } else if (ux == 0x7F800000) {\n        m = uy >> 31 ? 0 : 0x7F800000;\n      } else if (sx) {\n        m = 0x7FC00000;\n      } else {\n        m = reinterpret<u32>(<f32>exp2f(<f64>y * log2f(x)));\n      }\n      return reinterpret<f32>(m | sign);\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function seedRandom(value: i64): void {\n    NativeMath.seedRandom(value);\n  }\n\n  // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n  export function random(): f32 {\n    if (!random_seeded) seedRandom(reinterpret<i64>(seed()));\n\n    var s0 = random_state0_32;\n    var s1 = random_state1_32;\n    var r  = rotl<u32>(s0 * 0x9E3779BB, 5) * 5;\n\n    s1 ^= s0;\n    random_state0_32 = rotl<u32>(s0, 26) ^ s1 ^ (s1 << 9);\n    random_state1_32 = rotl<u32>(s1, 13);\n\n    return reinterpret<f32>((r >> 9) | (127 << 23)) - 1.0;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function round(x: f32): f32 {\n    return builtin_copysign<f32>(builtin_floor<f32>(x + 0.5), x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sign(x: f32): f32 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return builtin_abs(x) > 0 ? builtin_copysign<f32>(1, x) : x;\n    } else {\n      return x > 0 ? 1 : x < 0 ? -1 : x;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function signbit(x: f32): bool {\n    // @ts-ignore: type\n    return <bool>((reinterpret<u32>(x) >>> 31) & (x == x));\n  }\n\n  export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n    const s1pio2 = reinterpret<f64>(0x3FF921FB54442D18); // M_PI_2 * 1\n    const s2pio2 = reinterpret<f64>(0x400921FB54442D18); // M_PI_2 * 2\n    const s3pio2 = reinterpret<f64>(0x4012D97C7F3321D2); // M_PI_2 * 3\n    const s4pio2 = reinterpret<f64>(0x401921FB54442D18); // M_PI_2 * 4\n\n    var ix = reinterpret<u32>(x);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ix < 0x39800000) { // |x| < 2**-12\n        return x;\n      }\n      return sin_kernf(x);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ix <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ix <= 0x4016CBE3) { // |x| ~<= 3π/4\n          return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n        }\n        return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n      }\n\n      if (ix <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ix <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n        }\n        return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n      }\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) return x - x;\n\n    var n = rempio2f(x, ix, sign);\n    var y = rempio2f_y;\n\n    var t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n    return n & 2 ? -t : t;\n  }\n\n  export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n    var u = reinterpret<u32>(x) & 0x7FFFFFFF;\n    var absx = reinterpret<f32>(u);\n    var t: f32;\n    var h = builtin_copysign<f32>(0.5, x);\n    if (u < 0x42B17217) {\n      t = expm1(absx);\n      if (u < 0x3F800000) {\n        if (u < 0x3F800000 - (12 << 23)) return x;\n        return h * (2 * t - t * t / (t + 1));\n      }\n      return h * (t + t / (t + 1));\n    }\n    t = 2 * h * expo2f(absx);\n    return t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sqrt(x: f32): f32 {\n    return builtin_sqrt<f32>(x);\n  }\n\n  export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n    const t1pio2 = reinterpret<f64>(0x3FF921FB54442D18); // 1 * M_PI_2\n    const t2pio2 = reinterpret<f64>(0x400921FB54442D18); // 2 * M_PI_2\n    const t3pio2 = reinterpret<f64>(0x4012D97C7F3321D2); // 3 * M_PI_2\n    const t4pio2 = reinterpret<f64>(0x401921FB54442D18); // 4 * M_PI_2\n\n    var ix = reinterpret<u32>(x);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ix < 0x39800000) { // |x| < 2**-12\n        return x;\n      }\n      return tan_kernf(x, 0);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ix <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ix <= 0x4016CBE3) { // |x| ~<= 3π/4\n          return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n        } else {\n          return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n        }\n      }\n      if (ix <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ix <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n        } else {\n          return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n        }\n      }\n    }\n\n    // tan(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) return x - x;\n\n    // argument reduction\n    var n = rempio2f(x, ix, sign);\n    var y = rempio2f_y;\n    return tan_kernf(y, n & 1);\n  }\n\n  export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n    var u = reinterpret<u32>(x);\n    u &= 0x7FFFFFFF;\n    var y = reinterpret<f32>(u);\n    var t: f32;\n    if (u > 0x3F0C9F54) {\n      if (u > 0x41200000) t = 1 + 0 / y;\n      else {\n        t = expm1(2 * y);\n        t = 1 - 2 / (t + 2);\n      }\n    } else if (u > 0x3E82C578) {\n      t = expm1(2 * y);\n      t = t / (t + 2);\n    } else if (u >= 0x00800000) {\n      t = expm1(-2 * y);\n      t = -t / (t + 2);\n    } else t = y;\n    return builtin_copysign<f32>(t, x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function trunc(x: f32): f32 {\n    return builtin_trunc<f32>(x);\n  }\n\n  export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n    const\n      Ox1p24f   = reinterpret<f32>(0x4B800000),\n      Ox1p127f  = reinterpret<f32>(0x7F000000),\n      Ox1p_126f = reinterpret<f32>(0x00800000);\n    var y = x;\n    if (n > 127) {\n      y *= Ox1p127f;\n      n -= 127;\n      if (n > 127) {\n        y *= Ox1p127f;\n        n = builtin_min<i32>(n - 127, 127);\n      }\n    } else if (n < -126) {\n      y *= Ox1p_126f * Ox1p24f;\n      n += 126 - 24;\n      if (n < -126) {\n        y *= Ox1p_126f * Ox1p24f;\n        n = builtin_max<i32>(n + 126 - 24, -126);\n      }\n    }\n    return y * reinterpret<f32>(<u32>(0x7F + n) << 23);\n  }\n\n  export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n    var ux = reinterpret<u32>(x);\n    var uy = reinterpret<u32>(y);\n    var ex = <i32>(ux >> 23 & 0xFF);\n    var ey = <i32>(uy >> 23 & 0xFF);\n    var sx = ux & 0x80000000;\n    var uy1 = uy << 1;\n    if (uy1 == 0 || ex == 0xFF || isNaN<f32>(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    var ux1 = ux << 1;\n    if (ux1 <= uy1) {\n      if (ux1 == uy1) return 0 * x;\n      return x;\n    }\n    if (!ex) {\n      ex -= builtin_clz<u32>(ux << 9);\n      ux <<= -ex + 1;\n    } else {\n      ux &= <u32>-1 >> 9;\n      ux |= 1 << 23;\n    }\n    if (!ey) {\n      ey -= builtin_clz<u32>(uy << 9);\n      uy <<= -ey + 1;\n    } else {\n      uy &= <u32>-1 >> 9;\n      uy |= 1 << 23;\n    }\n    while (ex > ey) {\n      if (ux >= uy) {\n        if (ux == uy) return 0 * x;\n        ux -= uy;\n      }\n      ux <<= 1;\n      --ex;\n    }\n    if (ux >= uy) {\n      if (ux == uy) return 0 * x;\n      ux -= uy;\n    }\n    // for (; !(ux >> 23); ux <<= 1) --ex;\n    var shift = <i32>builtin_clz<u32>(ux << 8);\n    ex -= shift;\n    ux <<= shift;\n    if (ex > 0) {\n      ux -= 1 << 23;\n      ux |= <u32>ex << 23;\n    } else {\n      ux >>= -ex + 1;\n    }\n    ux |= sx;\n    return reinterpret<f32>(ux);\n  }\n\n  export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n    var ux = reinterpret<u32>(x);\n    var uy = reinterpret<u32>(y);\n    var ex = <i32>(ux >> 23 & 0xFF);\n    var ey = <i32>(uy >> 23 & 0xFF);\n    var sx = <i32>(ux >> 31);\n    var uxi = ux;\n    if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n    if (ux << 1 == 0) return x;\n    if (!ex) {\n      ex -= builtin_clz<u32>(uxi << 9);\n      uxi <<= -ex + 1;\n    } else {\n      uxi &= <u32>-1 >> 9;\n      uxi |= 1 << 23;\n    }\n    if (!ey) {\n      ey -= builtin_clz<u32>(uy << 9);\n      uy <<= -ey + 1;\n    } else {\n      uy &= <u32>-1 >> 9;\n      uy |= 1 << 23;\n    }\n    var q = 0;\n    do {\n      if (ex < ey) {\n        if (ex + 1 == ey) break; // goto end\n        return x;\n      }\n      while (ex > ey) {\n        if (uxi >= uy) {\n          uxi -= uy;\n          ++q;\n        }\n        uxi <<= 1;\n        q <<= 1;\n        --ex;\n      }\n      if (uxi >= uy) {\n        uxi -= uy;\n        ++q;\n      }\n      if (uxi == 0) ex = -30;\n      else {\n        let shift = builtin_clz<i32>(uxi << 8);\n        ex -= shift;\n        uxi <<= shift;\n      }\n      break;\n    } while (false);\n    // end:\n    if (ex > 0) {\n      uxi -= 1 << 23;\n      uxi |= <u32>ex << 23;\n    } else {\n      uxi >>= -ex + 1;\n    }\n    x = reinterpret<f32>(uxi);\n    y = builtin_abs<f32>(y);\n    var x2 = x + x;\n    if (ex == ey || (ex + 1 == ey && (<f32>x2 > y || (<f32>x2 == y && <bool>(q & 1))))) {\n      x -= y;\n      // q++;\n    }\n    return sx ? -x : x;\n  }\n\n  export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n    const s1pio2 = reinterpret<f64>(0x3FF921FB54442D18); // 1 * M_PI_2\n    const s2pio2 = reinterpret<f64>(0x400921FB54442D18); // 2 * M_PI_2\n    const s3pio2 = reinterpret<f64>(0x4012D97C7F3321D2); // 3 * M_PI_2\n    const s4pio2 = reinterpret<f64>(0x401921FB54442D18); // 4 * M_PI_2\n\n    var ix = reinterpret<u32>(x);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ix < 0x39800000) { // |x| < 2**-12\n        sincos_sin = x;\n        sincos_cos = 1;\n        return;\n      }\n      sincos_sin = sin_kernf(x);\n      sincos_cos = cos_kernf(x);\n      return;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ix <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ix <= 0x4016CBE3) { // |x| ~<= 3π/4\n          if (sign) {\n            sincos_sin = -cos_kernf(x + s1pio2);\n            sincos_cos =  sin_kernf(x + s1pio2);\n          } else {\n            sincos_sin = cos_kernf(s1pio2 - x);\n            sincos_cos = sin_kernf(s1pio2 - x);\n          }\n          return;\n        }\n        // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n        sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n        sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n        return;\n      }\n      if (ix <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ix <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          if (sign) {\n            sincos_sin =  cos_kernf(x + s3pio2);\n            sincos_cos = -sin_kernf(x + s3pio2);\n          } else {\n            sincos_sin = -cos_kernf(x - s3pio2);\n            sincos_cos =  sin_kernf(x - s3pio2);\n          }\n          return;\n        }\n        sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n        sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n        return;\n      }\n    }\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) {\n      let xx = x - x;\n      sincos_sin = xx;\n      sincos_cos = xx;\n      return;\n    }\n    // general argument reduction needed\n    var n = rempio2f(x, ix, sign);\n    var y = rempio2f_y;\n    var s = sin_kernf(y);\n    var c = cos_kernf(y);\n    var sin = s, cos = c;\n    if (n & 1) {\n      sin =  c;\n      cos = -s;\n    }\n    if (n & 2) {\n      sin = -sin;\n      cos = -cos;\n    }\n    sincos_sin = sin;\n    sincos_cos = cos;\n  }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n  var out = 1;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (e <= 0) {\n      if (x == -1) return select<i32>(-1, 1, e & 1);\n      return i32(e == 0) | i32(x == 1);\n    }\n    else if (e == 1) return x;\n    else if (e == 2) return x * x;\n    else if (e < 32) {\n      let log = 32 - clz(e);\n      // 32 = 2 ^ 5, so need only five cases.\n      // But some extra cases needs for properly overflowing\n      switch (log) {\n        case 5: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 4: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 3: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 2: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 1: {\n          if (e & 1) out *= x;\n        }\n      }\n      return out;\n    }\n  }\n  while (e) {\n    if (e & 1) out *= x;\n    e >>>= 1;\n    x *= x;\n  }\n  return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n  var out: i64 = 1;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (e <= 0) {\n      if (x == -1) return select<i64>(-1, 1, e & 1);\n      return i64(e == 0) | i64(x == 1);\n    }\n    else if (e == 1) return x;\n    else if (e == 2) return x * x;\n    else if (e < 64) {\n      let log = 64 - <i32>clz(e);\n      // 64 = 2 ^ 6, so need only six cases.\n      // But some extra cases needs for properly overflowing\n      switch (log) {\n        case 6: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 5: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 4: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 3: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 2: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 1: {\n          if (e & 1) out *= x;\n        }\n      }\n      return out;\n    }\n  }\n  while (e) {\n    if (e & 1) out *= x;\n    e >>>= 1;\n    x *= x;\n  }\n  return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n  case  1: return x;\n  case  2: return x * x;\n  case  3: return x * x * x;\n  case  4: return (b = x * x) * b;\n  case  5: return (b = x * x) * b * x;\n  case  6: return (b = x * x) * b * b;\n  case  7: return (b = x * x) * b * b * x;\n  case  8: return (d = (b = x * x) * b) * d;\n  case  9: return (c = x * x * x) * c * c;\n  case 10: return (d = (b = x * x) * b) * d * b;\n  case 11: return (d = (b = x * x) * b) * d * b * x;\n  case 12: return (d = (b = x * x) * b) * d * d;\n  case 13: return (d = (b = x * x) * b) * d * d * x;\n  case 14: return (d = (b = x * x) * b) * d * d * b;\n  case 15: return (k = (b = x * x) * b * x) * k * k;\n  case 16: return (h = (d = (b = x * x) * b) * d) * h;\n  case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n  case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n  case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n  case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n  case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n  case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n  case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n  case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n  case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n  case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n  case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n  case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n  case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n  case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n  case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n  case 32:\n  ...\n  case 63:\n}\n*/","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nconst leftPadding = (size: i32, input: string): string => {\n  if (input.length < size) {\n    input.padStart(size - input.length);\n    return \" \".repeat(size - input.length) + input;\n  }\n  return input;\n};\n\nexport const integerFormatter = (size: i32, integer: u64): string => {\n  return leftPadding(size, integer.toString());\n};\n\nexport class IntegerFormatter {\n  constructor(private size: i32) {}\n\n  format(integer: u64): string {\n    return leftPadding(this.size, integer.toString());\n  }\n}\n\nexport class FloatFormatter {\n  constructor(private size: i32, private fractionDigits: i32) {}\n\n  format(float: f64): string {\n    const intergerPart = <u64>Math.floor(float);\n    const digits = Math.pow(10, this.fractionDigits);\n    const floatPart = <u64>(\n      Math.round(float * digits - <f64>intergerPart * digits)\n    );\n    let floatPartString = floatPart.toString();\n    if (floatPartString.length < this.fractionDigits) {\n      floatPartString += \"0\".repeat(\n        this.fractionDigits - floatPartString.length\n      );\n    }\n\n    let result = intergerPart.toString() + \".\" + floatPartString;\n    if (result.length < this.size) {\n      result = \" \".repeat(this.size - result.length) + result;\n    }\n    return result;\n  }\n}\n","/// <reference path=\"../rt/index.d.ts\" />\n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<u32>([\n  1,\n  10,\n  100,\n  1000,\n  10000,\n  100000,\n  1000000,\n  10000000,\n  100000000,\n  1000000000\n]);\n\n/*\n  Lookup table for pairwise char codes in range [0-99]\n\n  \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n  \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n  \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n  \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n  \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n  \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n  \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n  \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n  \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n  \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data<u32>([\n  0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n  0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n  0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n  0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n  0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n  0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n  0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n  0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n  0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n  0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n  0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n  0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n  0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n  0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n  0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n  0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n  0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n  0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n  0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n  0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data<i16>([/* eslint-disable indent */\n  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,\n   -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,\n   -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,\n   -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,\n   -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,\n    109,   136,   162,   189,   216,   242,   269,   295,   322,   348,\n    375,   402,   428,   455,   481,   508,   534,   561,   588,   614,\n    641,   667,   694,   720,   747,   774,   800,   827,   853,   880,\n    907,   933,   960,   986,  1013,  1039,  1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data<u64>([\n  0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n  0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n  0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n  0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n  0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n  0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n  0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n  0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n  0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n  0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n  0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n  0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n  0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n  0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n  0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n  0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n  0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n  0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n  0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n  0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n  0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n  0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n  if (value < 100000) {\n    if (value < 100) {\n      return 1 + u32(value >= 10);\n    } else {\n      return 3 + u32(value >= 10000) + u32(value >= 1000);\n    }\n  } else {\n    if (value < 10000000) {\n      return 6 + u32(value >= 1000000);\n    } else {\n      return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n    }\n  }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n  if (value < 1000000000000000) {\n    if (value < 1000000000000) {\n      return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n    } else {\n      return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n    }\n  } else {\n    if (value < 100000000000000000) {\n      return 16 + u32(value >= 10000000000000000);\n    } else {\n      return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n    }\n  }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n  if ((base & (base - 1)) == 0) { // if base is pow of two\n    return (63 - <u32>clz(num)) / (31 - <u32>clz(base)) + 1;\n  }\n  var b64 = u64(base), b = b64, e: u32 = 1;\n  while (num >= b) {\n    num /= b;\n    b *= b;\n    e <<= 1;\n  }\n  while (num >= 1) {\n    num /= b64;\n    e++;\n  }\n  return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n  while (num >= 10000) {\n    // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n    let t = num / 10000;\n    let r = num % 10000;\n    num = t;\n\n    let d1 = r / 100;\n    let d2 = r % 100;\n\n    let digits1 = <u64>load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n    let digits2 = <u64>load<u32>(DIGITS + (<usize>d2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n  }\n\n  if (num >= 100) {\n    let t  = num / 100;\n    let d1 = num % 100;\n    num = t;\n    offset -= 2;\n    let digits = load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n    store<u32>(buffer + (offset << 1), digits);\n  }\n\n  if (num >= 10) {\n    offset -= 2;\n    let digits = load<u32>(DIGITS + (<usize>num << alignof<u32>()));\n    store<u32>(buffer + (offset << 1), digits);\n  } else {\n    offset -= 1;\n    let digit = CharCode._0 + num;\n    store<u16>(buffer + (offset << 1), digit);\n  }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n  while (num >= 100000000) {\n    let t = num / 100000000;\n    let r = <usize>(num - t * 100000000);\n    num = t;\n\n    let b = r / 10000;\n    let c = r % 10000;\n\n    let b1 = b / 100;\n    let b2 = b % 100;\n    let c1 = c / 100;\n    let c2 = c % 100;\n\n    let digits1 = <u64>load<u32>(DIGITS + (<usize>c1 << alignof<u32>()));\n    let digits2 = <u64>load<u32>(DIGITS + (<usize>c2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n    digits1 = <u64>load<u32>(DIGITS + (<usize>b1 << alignof<u32>()));\n    digits2 = <u64>load<u32>(DIGITS + (<usize>b2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n  }\n\n  utoa32_dec_lut(buffer, <u32>num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n  const lut = changetype<usize>(HEX_DIGITS);\n  while (offset >= 2) {\n    offset -= 2;\n    store<u32>(\n      buffer + (offset << 1),\n      load<u32>(lut + ((<usize>num & 0xFF) << alignof<u32>()))\n    );\n    num >>= 8;\n  }\n  if (offset & 1) {\n    store<u16>(buffer, load<u16>(lut + (<usize>num << 6)));\n  }\n}\n\nfunction utoa_dec_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n  do {\n    let t = num / 10;\n    let r = <u32>(num % 10);\n    num = changetype<T>(t);\n    offset--;\n    store<u16>(buffer + (offset << 1), CharCode._0 + r);\n  } while (num);\n}\n\nfunction utoa_hex_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n  do {\n    let d = num & 0x0F | CharCode._0;\n    d += select<T>(<T>0x27, <T>0, d > <T>CharCode._9);\n    offset--;\n    store<u16>(buffer + (offset << 1), d);\n    // @ts-ignore: type\n    num >>= 4;\n  } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_dec_simple<u32>(buffer, num, offset);\n  } else {\n    utoa32_dec_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_hex_simple<u32>(buffer, num, offset);\n  } else {\n    utoa_hex_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_dec_simple<u64>(buffer, num, offset);\n  } else {\n    utoa64_dec_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_hex_simple<u64>(buffer, num, offset);\n  } else {\n    utoa_hex_lut(buffer, num, offset);\n  }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n  const lut = changetype<usize>(ANY_DIGITS);\n  var base = u64(radix);\n  if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n    let shift = u64(ctz(radix) & 7);\n    let mask = base - 1;\n    do {\n      offset--;\n      store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num & mask) << 1)));\n      num >>= shift;\n    } while (num);\n  } else {\n    do {\n      offset--;\n      let q = num / base;\n      store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num - q * base) << 1)));\n      num = q;\n    } while (num);\n  }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n  var out: usize = 0;\n\n  if (radix == 10) {\n    let decimals = decimalCount32(value);\n    out = __alloc(decimals << 1, idof<String>());\n    utoa32_dec_core(out, value, decimals);\n  } else if (radix == 16) {\n    let decimals = (31 - clz(value) >> 2) + 1;\n    out = __alloc(decimals << 1, idof<String>());\n    utoa32_hex_core(out, value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = __alloc(decimals << 1, idof<String>());\n    utoa64_any_core(out, value, decimals, radix);\n  }\n  return changetype<String>(out); // retains\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n\n  var sign = value >>> 31;\n  if (sign) value = -value;\n  var out: usize = 0;\n\n  if (radix == 10) {\n    let decimals = decimalCount32(value) + sign;\n    out = __alloc(decimals << 1, idof<String>());\n    utoa32_dec_core(out, value, decimals);\n  } else if (radix == 16) {\n    let decimals = (31 - clz(value) >> 2) + 1 + sign;\n    out = __alloc(decimals << 1, idof<String>());\n    utoa32_hex_core(out, value, decimals);\n  } else {\n    let val32 = u32(value);\n    let decimals = ulog_base(val32, radix) + sign;\n    out = __alloc(decimals << 1, idof<String>());\n    utoa64_any_core(out, val32, decimals, radix);\n  }\n  if (sign) store<u16>(out, CharCode.MINUS);\n  return changetype<String>(out); // retains\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n  var out: usize = 0;\n\n  if (radix == 10) {\n    if (value <= u32.MAX_VALUE) {\n      let val32    = <u32>value;\n      let decimals = decimalCount32(val32);\n      out = __alloc(decimals << 1, idof<String>());\n      utoa32_dec_core(out, val32, decimals);\n    } else {\n      let decimals = decimalCount64High(value);\n      out = __alloc(decimals << 1, idof<String>());\n      utoa64_dec_core(out, value, decimals);\n    }\n  } else if (radix == 16) {\n    let decimals = (63 - u32(clz(value)) >> 2) + 1;\n    out = __alloc(decimals << 1, idof<String>());\n    utoa64_hex_core(out, value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = __alloc(decimals << 1, idof<String>());\n    utoa64_any_core(out, value, decimals, radix);\n  }\n  return changetype<String>(out); // retains\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n\n  var sign = u32(value >>> 63);\n  if (sign) value = -value;\n  var out: usize = 0;\n\n  if (radix == 10) {\n    if (<u64>value <= <u64>u32.MAX_VALUE) {\n      let val32    = <u32>value;\n      let decimals = decimalCount32(val32) + sign;\n      out = __alloc(decimals << 1, idof<String>());\n      utoa32_dec_core(out, val32, decimals);\n    } else {\n      let decimals = decimalCount64High(value) + sign;\n      out = __alloc(decimals << 1, idof<String>());\n      utoa64_dec_core(out, value, decimals);\n    }\n  } else if (radix == 16) {\n    let decimals = (63 - u32(clz(value)) >> 2) + 1 + sign;\n    out = __alloc(decimals << 1, idof<String>());\n    utoa64_hex_core(out, value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix) + sign;\n    out = __alloc(decimals << 1, idof<String>());\n    utoa64_any_core(out, value, decimals, radix);\n  }\n  if (sign) store<u16>(out, CharCode.MINUS);\n  return changetype<String>(out); // retains\n}\n\n// @ts-ignore: decorator\n@lazy var _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// var _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy var _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy var _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy var _frc_plus:  u64 = 0;\n\n// @ts-ignore: decorator\n@lazy var _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy var _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n  var u0 = u & 0xFFFFFFFF;\n  var v0 = v & 0xFFFFFFFF;\n\n  var u1 = u >> 32;\n  var v1 = v >> 32;\n\n  var l = u0 * v0;\n  var t = u1 * v0 + (l >> 32);\n  var w = u0 * v1 + (t & 0xFFFFFFFF);\n\n  w += 0x7FFFFFFF; // rounding\n\n  t >>= 32;\n  w >>= 32;\n\n  return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n  return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32): void {\n  var frc = (f << 1) + 1;\n  var exp = e - 1;\n  var off = <i32>clz<u64>(frc);\n  frc <<= off;\n  exp  -= off;\n\n  var m = 1 + i32(f == 0x0010000000000000);\n\n  _frc_plus  = frc;\n  _frc_minus = ((f << m) - 1) << e - m - exp;\n  _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n  var lastp = buffer + ((len - 1) << 1);\n  var digit = load<u16>(lastp);\n  while (\n    rest < wp_w &&\n    delta - rest >= ten_kappa && (\n      rest + ten_kappa < wp_w ||\n      wp_w - rest > rest + ten_kappa - wp_w\n    )\n  ) {\n    --digit;\n    rest += ten_kappa;\n  }\n  store<u16>(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n  const c = reinterpret<f64>(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n  var dk = (-61 - minExp) * c + 347;\t            // dk must be positive, so can do ceiling in positive\n  var k = <i32>dk;\n  k += i32(k != dk); // conversion with ceil\n\n  var index = (k >> 3) + 1;\n  _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n  _frc_pow = load<u64>(FRC_POWERS + (<usize>index << alignof<u64>()));\n  _exp_pow = load<i16>(EXP_POWERS + (<usize>index << alignof<i16>()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32): i32 {\n\n  // frexp routine\n  var uv  = reinterpret<u64>(value);\n  var exp = i32((uv & 0x7FF0000000000000) >>> 52);\n  var sid = uv & 0x000FFFFFFFFFFFFF;\n  var frc = (u64(exp != 0) << 52) + sid;\n  exp = select<i32>(exp, 1, exp) - (0x3FF + 52);\n\n  normalizedBoundaries(frc, exp);\n  getCachedPower(_exp);\n\n  // normalize\n  var off = <i32>clz<u64>(frc);\n  frc <<= off;\n  exp  -= off;\n\n  var frc_pow = _frc_pow;\n  var exp_pow = _exp_pow;\n\n  var w_frc = umul64f(frc, frc_pow);\n  var w_exp = umul64e(exp, exp_pow);\n\n  var wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n  var wp_exp = umul64e(_exp, exp_pow);\n\n  var wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n  var delta  = wp_frc - wm_frc;\n\n  return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n  var one_exp = -mp_exp;\n  var one_frc = (<u64>1) << one_exp;\n  var mask    = one_frc - 1;\n\n  var wp_w_frc = mp_frc - w_frc;\n\n  var p1 = u32(mp_frc >> one_exp);\n  var p2 = mp_frc & mask;\n\n  var kappa = <i32>decimalCount32(p1);\n  var len = sign;\n\n  while (kappa > 0) {\n    let d: u32;\n    switch (kappa) {\n      case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n      case  9: { d = p1 /  100000000; p1 %=  100000000; break; }\n      case  8: { d = p1 /   10000000; p1 %=   10000000; break; }\n      case  7: { d = p1 /    1000000; p1 %=    1000000; break; }\n      case  6: { d = p1 /     100000; p1 %=     100000; break; }\n      case  5: { d = p1 /      10000; p1 %=      10000; break; }\n      case  4: { d = p1 /       1000; p1 %=       1000; break; }\n      case  3: { d = p1 /        100; p1 %=        100; break; }\n      case  2: { d = p1 /         10; p1 %=         10; break; }\n      case  1: { d = p1;              p1 =           0; break; }\n      default: { d = 0; break; }\n    }\n\n    if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n    --kappa;\n    let tmp = ((<u64>p1) << one_exp) + p2;\n    if (tmp <= delta) {\n      _K += kappa;\n      grisuRound(buffer, len, delta, tmp, <u64>load<u32>(POWERS10 + (<usize>kappa << alignof<u32>())) << one_exp, wp_w_frc);\n      return len;\n    }\n  }\n\n  while (true) {\n    p2    *= 10;\n    delta *= 10;\n\n    let d = p2 >> one_exp;\n    if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n    p2 &= mask;\n    --kappa;\n    if (p2 < delta) {\n      _K += kappa;\n      wp_w_frc *= <u64>load<u32>(POWERS10 + (<usize>-kappa << alignof<u32>()));\n      grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n      return len;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n  var sign = k < 0;\n  if (sign) k = -k;\n  var decimals = decimalCount32(k) + 1;\n  utoa32_dec_core(buffer, k, decimals);\n  store<u16>(buffer, <u16>select<u32>(CharCode.MINUS, CharCode.PLUS, sign));\n  return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n  if (!k) {\n    store<u32>(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n    return length + 2;\n  }\n\n  var kk = length + k;\n  if (length <= kk && kk <= 21) {\n    // 1234e7 -> 12340000000\n    for (let i = length; i < kk; ++i) {\n      store<u16>(buffer + (i << 1), CharCode._0);\n    }\n    store<u32>(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n    return kk + 2;\n  } else if (kk > 0 && kk <= 21) {\n    // 1234e-2 -> 12.34\n    let ptr = buffer + (kk << 1);\n    memory.copy(\n      ptr + 2,\n      ptr,\n      -k << 1\n    );\n    store<u16>(buffer + (kk << 1), CharCode.DOT);\n    return length + 1;\n  } else if (-6 < kk && kk <= 0) {\n    // 1234e-6 -> 0.001234\n    let offset = 2 - kk;\n    memory.copy(\n      buffer + (offset << 1),\n      buffer,\n      length << 1\n    );\n    store<u32>(buffer, CharCode._0 | (CharCode.DOT << 16));\n    for (let i = 2; i < offset; ++i) {\n      store<u16>(buffer + (i << 1), CharCode._0);\n    }\n    return length + offset;\n  } else if (length == 1) {\n    // 1e30\n    store<u16>(buffer, CharCode.e, 2);\n    length = genExponent(buffer + 4, kk - 1);\n    return length + 2;\n  } else {\n    let len = length << 1;\n    memory.copy(\n      buffer + 4,\n      buffer + 2,\n      len - 2\n    );\n    store<u16>(buffer,       CharCode.DOT, 2);\n    store<u16>(buffer + len, CharCode.e,   2);\n    length += genExponent(buffer + len + 4, kk - 1);\n    return length + 2;\n  }\n}\n\nfunction dtoa_core(buffer: usize, value: f64): i32 {\n  var sign = i32(value < 0);\n  if (sign) {\n    value = -value;\n    store<u16>(buffer, CharCode.MINUS);\n  }\n  // assert(value > 0 && value <= 1.7976931348623157e308);\n  var len = grisu2(value, buffer, sign);\n  len = prettify(buffer + (sign << 1), len - sign, _K);\n  return len + sign;\n}\n\nexport function dtoa(value: f64): String {\n  if (value == 0) return \"0.0\";\n  if (!isFinite(value)) {\n    if (isNaN(value)) return \"NaN\";\n    return select<String>(\"-Infinity\", \"Infinity\", value < 0);\n  }\n  var buffer = __alloc(MAX_DOUBLE_LENGTH << 1, idof<String>());\n  var length = dtoa_core(buffer, value);\n  if (length == MAX_DOUBLE_LENGTH) return changetype<String>(buffer);\n  var result = changetype<String>(buffer).substring(0, length);\n  __free(buffer);\n  return result;\n}\n\nexport function itoa_buffered<T extends number>(buffer: usize, value: T): u32 {\n  var sign: u32 = 0;\n  if (isSigned<T>()) {\n    sign = u32(value < 0);\n    if (sign) {\n      value = changetype<T>(-value);\n      store<u16>(buffer, CharCode.MINUS);\n    }\n  }\n  if (ASC_SHRINK_LEVEL <= 1) {\n    if (isSigned<T>()) {\n      if (sizeof<T>() <= 4) {\n        if (<u32>value < 10) {\n          store<u16>(buffer + (sign << 1), value | CharCode._0);\n          return 1 + sign;\n        }\n      } else {\n        if (<u64>value < 10) {\n          store<u16>(buffer + (sign << 1), value | CharCode._0);\n          return 1 + sign;\n        }\n      }\n    } else {\n      if (value < 10) {\n        store<u16>(buffer, value | CharCode._0);\n        return 1;\n      }\n    }\n  }\n  var decimals = sign;\n  if (sizeof<T>() <= 4) {\n    decimals += decimalCount32(value);\n    utoa32_dec_core(buffer, value, decimals);\n  } else {\n    if (<u64>value <= <u64>u32.MAX_VALUE) {\n      let val32 = <u32>value;\n      decimals += decimalCount32(val32);\n      utoa32_dec_core(buffer, val32, decimals);\n    } else {\n      decimals += decimalCount64High(value);\n      utoa64_dec_core(buffer, value, decimals);\n    }\n  }\n  return decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: f64): u32 {\n  if (value == 0) {\n    store<u16>(buffer, CharCode._0);\n    store<u16>(buffer, CharCode.DOT, 2);\n    store<u16>(buffer, CharCode._0,  4);\n    return 3;\n  }\n  if (!isFinite(value)) {\n    if (isNaN(value)) {\n      store<u16>(buffer, CharCode.N);\n      store<u16>(buffer, CharCode.a, 2);\n      store<u16>(buffer, CharCode.N, 4);\n      return 3;\n    } else {\n      let sign = value < 0;\n      if (sign) {\n        store<u16>(buffer, CharCode.MINUS); // -\n        buffer += 2;\n      }\n      store<u64>(buffer, 0x690066006E0049, 0); // ifnI\n      store<u64>(buffer, 0x7900740069006E, 8); // ytin\n      return 8 + u32(sign);\n    }\n  }\n  return dtoa_core(buffer, value);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa, itoa_buffered, dtoa_buffered, MAX_DOUBLE_LENGTH } from \"./number\";\nimport { ipow32 } from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data<u8>([\n  18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n  41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n  68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n  93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n  17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n  119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n  16,16,125,16,16,16,\n  16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n  255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n  251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n  255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n  255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n  31,254,225,255,\n  159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n  255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n  1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n  255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n  197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n  94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n  159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n  255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n  207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n  253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n  251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n  0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n  0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n  31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n  255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n  255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n  127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n  7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n  255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n  255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n  255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n  63,\n  0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n  255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n  127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n  255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n  255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n  255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n  128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n  255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n  224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n  0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n  255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n  255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n  255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n  255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,\n  31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n  0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n  255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n  0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n  255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n  255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n  255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n  255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n  255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n  126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n  255,\n  15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n  255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n  252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n  254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n  252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n  0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n  255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n  255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n  127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n  254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n  255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n  0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n  0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n  255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n  0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n  255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n  255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n  127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n  253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n  255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n  255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n  3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n  7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n  255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n  127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n  255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n  255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n  255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n  0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n  0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,\n  0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n  255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n  255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n  255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n  255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n  127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n  223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n  255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n  247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n  255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n  128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n  3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n  132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data<u8>([\n  18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n  24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n  29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n  16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n  16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n  16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n  255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n  0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n  255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n  255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n  191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n  255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n  132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n  255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n  255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n  255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n  255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n  0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n  254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n  255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n  255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n  95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n  253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n  255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n  15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data<u8>([\n  18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n  33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n  43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n  47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n  16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n  66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n  88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n  16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n  0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n  1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n  0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n  0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n  254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n  6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n  190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n  4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n  193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n  3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n  0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n  0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n  0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n  0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n  0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n  0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n  0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n  0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n  15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n  0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n  0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n  255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n  3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n  0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n  0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n  0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n  0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n  255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n  128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n  0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n  2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n  255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n  0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n  0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n  0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n  3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n  3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n  0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n  0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n  0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n  0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n  0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n  231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n  0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data<u8>([\n  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n  16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n  32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n  48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n  64,\n  97,98,99,100,101,102,103,104,105,106,107,108,109,\n  110,111,112,113,114,115,116,117,118,119,120,121,122,\n  91,92,93,94,95,96,\n  97,98,99,100,101,102,103,104,105,106,107,108,109,\n  110,111,112,113,114,115,116,117,118,119,120,121,122,\n  123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data<u8>([\n  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n  16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n  32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n  48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n  64,\n  65,66,67,68,69,70,71,72,73,74,75,76,77,\n  78,79,80,81,82,83,84,85,86,87,88,89,90,\n  91,92,93,94,95,96,\n  65,66,67,68,69,70,71,72,73,74,75,76,77,\n  78,79,80,81,82,83,84,85,86,87,88,89,90,\n  123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<f64>([\n  1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n  1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n  1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n  PLUS = 0x2B,\n  MINUS = 0x2D,\n  DOT = 0x2E,\n  _0 = 0x30,\n  _1 = 0x31,\n  _2 = 0x32,\n  _3 = 0x33,\n  _4 = 0x34,\n  _5 = 0x35,\n  _6 = 0x36,\n  _7 = 0x37,\n  _8 = 0x38,\n  _9 = 0x39,\n  A = 0x41,\n  B = 0x42,\n  E = 0x45,\n  I = 0x49,\n  N = 0x4E,\n  O = 0x4F,\n  X = 0x58,\n  Z = 0x5A,\n  a = 0x61,\n  b = 0x62,\n  e = 0x65,\n  n = 0x6E,\n  o = 0x6F,\n  x = 0x78,\n  z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n  return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n  return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n  return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n  if (c < 0x1680) { // < <LS> (1)\n    // <SP>, <TAB>, <LF>, <VT>, <FF>, <CR> and <NBSP>\n    // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n    // @ts-ignore: cast\n    return ((c | 0x80) == 0xA0) | (c - 0x09 <= 0x0D - 0x09);\n  }\n  if (c - 0x2000 <= 0x200A - 0x2000) return true;\n  switch (c) {\n    case 0x1680: // <LS> (1)\n    case 0x2028: // <LS> (2)\n    case 0x2029: // <PS>\n    case 0x202F: // <NNS>\n    case 0x205F: // <MMSP>\n    case 0x3000: // <IS>\n    case 0xFEFF: return true; // <ZWNBSP>\n  }\n  return false;\n}\n\nexport function isAlpha(c: u32): bool {\n  if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n  if (c < 0x20000) {\n    // @ts-ignore: cast\n    return stagedBinaryLookup(ALPHA_TABLE, c);\n  }\n  return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n  // @ts-ignore: cast\n  return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n  // @ts-ignore: cast\n  return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n  const lookaheadLimit = 30; // max lookahead limit\n  var found = false;\n  var pos = index;\n  var minPos = max(0, pos - lookaheadLimit);\n  while (pos > minPos) {\n    let c = codePointBefore(buffer, pos);\n    if (!isCaseIgnorable(c)) {\n      if (isCased(c)) {\n        found = true;\n      } else {\n        return false;\n      }\n    }\n    pos -= isize(c >= 0x10000) + 1;\n  }\n  if (!found) return false;\n  pos = index + 1;\n  var maxPos = min(pos + lookaheadLimit, len);\n  while (pos < maxPos) {\n    let c = <u32>load<u16>(buffer + (pos << 1));\n    if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n      let c1 = <u32>load<u16>(buffer + (pos << 1), 2);\n      if ((c1 & 0xFC00) == 0xDC00) {\n        c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n      }\n    }\n    if (!isCaseIgnorable(c)) {\n      return !isCased(c);\n    }\n    pos += isize(c >= 0x10000) + 1;\n  }\n  return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n  if (index <= 0) return -1;\n  var c = <u32>load<u16>(buffer + (index - 1 << 1));\n  if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n    let c1 = <u32>load<u16>(buffer + (index - 2 << 1));\n    if ((c1 & 0xFC00) == 0xD800) {\n      return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n    }\n  }\n  return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n  return <bool>((load<u8>(table + (<u32>load<u8>(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n  var ptr1 = changetype<usize>(str1) + (index1 << 1);\n  var ptr2 = changetype<usize>(str2) + (index2 << 1);\n  if (ASC_SHRINK_LEVEL < 2) {\n    if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n      do {\n        if (load<u64>(ptr1) != load<u64>(ptr2)) break;\n        ptr1 += 8;\n        ptr2 += 8;\n        len  -= 4;\n      } while (len >= 4);\n    }\n  }\n  while (len--) {\n    let a = <i32>load<u16>(ptr1);\n    let b = <i32>load<u16>(ptr2);\n    if (a != b) return a - b;\n    ptr1 += 2;\n    ptr2 += 2;\n  }\n  return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    return c | u32(isUpper8(c)) << 5;\n  } else {\n    return <u32>load<u8>(LOWER127 + c);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    return c & ~(u32(isLower8(c)) << 5);\n  } else {\n    return <u32>load<u8>(UPPER127 + c);\n  }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol<T>(str: string, radix: i32 = 0): T {\n  var len = str.length;\n  if (!len) {\n    // @ts-ignore: cast\n    if (isFloat<T>()) return <T>NaN;\n    // @ts-ignore: cast\n    return <T>0;\n  }\n\n  var ptr = changetype<usize>(str) /* + HEAD -> offset */;\n  var code = <u32>load<u16>(ptr);\n\n  // determine sign\n  // @ts-ignore: cast\n  var sign: T = 1;\n  // trim white spaces\n  while (isSpace(code)) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (code == CharCode.MINUS) {\n    if (!--len) {\n      // @ts-ignore: cast\n      if (isFloat<T>()) return <T>NaN;\n      // @ts-ignore: cast\n      return <T>0;\n    }\n    code = <u32>load<u16>(ptr += 2);\n    // @ts-ignore: type\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) {\n      // @ts-ignore: cast\n      if (isFloat<T>()) return <T>NaN;\n      // @ts-ignore: cast\n      return <T>0;\n    }\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  // determine radix\n  if (!radix) {\n    if (code == CharCode._0 && len > 2) {\n      switch (<u32>load<u16>(ptr + 2) | 32) {\n        case CharCode.b: {\n          ptr += 4; len -= 2;\n          radix = 2;\n          break;\n        }\n        case CharCode.o: {\n          ptr += 4; len -= 2;\n          radix = 8;\n          break;\n        }\n        case CharCode.x: {\n          ptr += 4; len -= 2;\n          radix = 16;\n          break;\n        }\n        default: radix = 10;\n      }\n    } else radix = 10;\n  } else if (radix < 2 || radix > 36) {\n    // @ts-ignore: cast\n    if (isFloat<T>()) return <T>NaN;\n    // @ts-ignore: cast\n    return <T>0;\n  }\n\n  // calculate value\n  // @ts-ignore: type\n  var num: T = 0;\n  while (len--) {\n    code = <u32>load<u16>(ptr);\n    if (code - CharCode._0 < 10) {\n      code -= CharCode._0;\n    } else if (code - CharCode.A <= <u32>(CharCode.Z - CharCode.A)) {\n      code -= CharCode.A - 10;\n    } else if (code - CharCode.a <= <u32>(CharCode.z - CharCode.a)) {\n      code -= CharCode.a - 10;\n    } else break;\n    if (code >= <u32>radix) break;\n    // @ts-ignore: type\n    num = num * radix + code;\n    ptr += 2;\n  }\n  // @ts-ignore: type\n  return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n  var len = str.length;\n  if (!len) return NaN;\n\n  var ptr  = changetype<usize>(str);\n  var code = <u32>load<u16>(ptr);\n\n  var sign = 1.;\n  // skip white spaces\n  while (len && isSpace(code)) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (!len) return NaN;\n\n  // try parse '-' or '+'\n  if (code == CharCode.MINUS) {\n    if (!--len) return NaN;\n    code = <u32>load<u16>(ptr += 2);\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) return NaN;\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  // try parse Infinity\n  if (len >= 8 && code == CharCode.I) {\n    if (\n      load<u64>(ptr, 0) == 0x690066006E0049 && // ifnI\n      load<u64>(ptr, 8) == 0x7900740069006E    // ytin\n    ) {\n      return copysign<f64>(Infinity, sign);\n    }\n    return NaN;\n  }\n  // validate next symbol\n  if (code != CharCode.DOT && <u32>(code - CharCode._0) >= 10) {\n    return NaN;\n  }\n  var savedPtr = ptr;\n  // skip zeros\n  while (code == CharCode._0) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (len <= 0) return 0;\n  const capacity = 19; // int(64 * 0.3010)\n  var pointed = false;\n  var consumed = 0;\n  var position = 0;\n  var x: u64 = 0;\n  if (code == CharCode.DOT) {\n    let noDigits = !(savedPtr - ptr);\n    ptr += 2; --len;\n    if (!len && noDigits) return NaN;\n    for (pointed = true; (code = <u32>load<u16>(ptr)) == CharCode._0; --position, ptr += 2) --len;\n    if (len <= 0) return 0;\n    if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n  }\n  for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n    if (digit < 10) {\n      x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n      ++consumed;\n    } else {\n      position = consumed;\n      pointed = true;\n    }\n    if (!--len) break;\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  if (!pointed) position = consumed;\n  return copysign<f64>(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) return select(\"true\", \"false\", load<bool>(dataStart));\n\n  var sepLen = separator.length;\n  var valueLen = 5; // max possible length of element len(\"false\")\n  var estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  var result = changetype<string>(__alloc(estLen << 1, idof<string>())); // retains\n  var offset = 0;\n  var value: bool;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<bool>(dataStart + i);\n    valueLen = 4 + i32(!value);\n    memory.copy(\n      changetype<usize>(result) + (<usize>offset << 1),\n      changetype<usize>(select(\"true\", \"false\", value)),\n      <usize>valueLen << 1\n    );\n    offset += valueLen;\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<bool>(dataStart + <usize>lastIndex);\n  valueLen = 4 + i32(!value);\n  memory.copy(\n    changetype<usize>(result) + (<usize>offset << 1),\n    changetype<usize>(select(\"true\", \"false\", value)),\n    valueLen << 1\n  );\n  offset += valueLen;\n\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinIntegerArray<T>(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    let value = load<T>(dataStart);\n    if (isSigned<T>()) {\n      if (sizeof<T>() <= 4) {\n        // @ts-ignore: type\n        return changetype<string>(itoa32(<i32>value, 10)); // retains\n      } else {\n        // @ts-ignore: type\n        return changetype<string>(itoa64(<i32>value, 10)); // retains\n      }\n    } else {\n      if (sizeof<T>() <= 4) {\n        // @ts-ignore: type\n        return changetype<string>(utoa32(<u32>value, 10)); // retains\n      } else {\n        // @ts-ignore: type\n        return changetype<string>(utoa64(<u64>value, 10)); // retains\n      }\n    }\n  }\n\n  var sepLen = separator.length;\n  const valueLen = (sizeof<T>() <= 4 ? 10 : 20) + i32(isSigned<T>());\n  var estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  var result = changetype<string>(__alloc(estLen << 1, idof<string>())); // retains\n  var offset = 0;\n  var value: T;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    offset += itoa_buffered<T>(changetype<usize>(result) + (<usize>offset << 1), value);\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  offset += itoa_buffered<T>(changetype<usize>(result) + (<usize>offset << 1), value);\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinFloatArray<T>(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    return changetype<string>(dtoa(\n      // @ts-ignore: type\n      load<T>(dataStart))\n    ); // retains\n  }\n\n  const valueLen = MAX_DOUBLE_LENGTH;\n  var sepLen = separator.length;\n  var estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  var result = changetype<string>(__alloc(estLen << 1, idof<string>())); // retains\n  var offset = 0;\n  var value: T;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    offset += dtoa_buffered(changetype<usize>(result) + (<usize>offset << 1), value);\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  offset += dtoa_buffered(changetype<usize>(result) + (<usize>offset << 1), value);\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    // @ts-ignore: type\n    return load<string>(dataStart) || \"\";\n  }\n  var estLen = 0;\n  var value: string;\n  for (let i = 0; i < length; ++i) {\n    value = load<string>(dataStart + (<usize>i << alignof<string>()));\n    // @ts-ignore: type\n    if (value !== null) estLen += value.length;\n  }\n  var offset = 0;\n  var sepLen = separator.length;\n  var result = __alloc((estLen + sepLen * lastIndex) << 1, idof<string>());\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<string>(dataStart + (<usize>i << alignof<string>()));\n    if (value !== null) {\n      let valueLen = value.length;\n      memory.copy(\n        result + (<usize>offset << 1),\n        changetype<usize>(value),\n        <usize>valueLen << 1\n      );\n      offset += valueLen;\n    }\n    if (sepLen) {\n      memory.copy(\n        result + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<string>(dataStart + (<usize>lastIndex << alignof<string>()));\n  if (value !== null) {\n    memory.copy(\n      result + (<usize>offset << 1),\n      changetype<usize>(value),\n      <usize>value.length << 1\n    );\n  }\n  return changetype<string>(result); // retains\n}\n\nexport function joinReferenceArray<T>(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  var value: T;\n  if (!lastIndex) {\n    value = load<T>(dataStart);\n    // @ts-ignore: type\n    return value !== null ? value.toString() : \"\";\n  }\n  var result = \"\";\n  var sepLen = separator.length;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    if (value !== null) result += value.toString();\n    if (sepLen) result += separator;\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  if (value !== null) result += value.toString();\n  return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n  if (!significand || exp < -342) return 0;\n  if (exp > 308) return Infinity;\n  // Try use fast path\n  // Use fast path for string-to-double conversion if possible\n  // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n  // Simple integer\n  var significandf = <f64>significand;\n  if (!exp) return significandf;\n  if (exp > 22 && exp <= 22 + 15) {\n    significandf *= pow10(exp - 22);\n    exp = 22;\n  }\n  if (significand <= 9007199254740991 && abs(exp) <= 22) {\n    if (exp > 0) return significandf * pow10(exp);\n    return significandf / pow10(-exp);\n  } else if (exp < 0) {\n    return scaledown(significand, exp);\n  } else {\n    return scaleup(significand, exp);\n  }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n  const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n  const scale = reinterpret<f64>(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n  var shift = clz(significand);\n  significand <<= shift;\n  shift = exp - shift;\n\n  for (; exp <= -14; exp += 14) {\n    let q = significand / denom;\n    let r = significand % denom;\n    let s = clz(q);\n    significand = (q << s) + <u64>nearest(scale * <f64>(r << (s - 18)));\n    shift -= s;\n  }\n  var b = <u64>ipow32(5, -exp);\n  var q = significand / b;\n  var r = significand % b;\n  var s = clz(q);\n  significand = (q << s) + <u64>(reinterpret<f64>(reinterpret<u64>(<f64>r) + (s << 52)) / <f64>b);\n  shift -= s;\n\n  return NativeMath.scalbn(<f64>significand, <i32>shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n  const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n  var shift = ctz(significand);\n  significand >>= shift;\n  shift += exp;\n\n  __fixmulShift = shift;\n  for (; exp >= 13; exp -= 13) {\n    significand = fixmul(significand, coeff);\n  }\n  significand = fixmul(significand, <u32>ipow32(5, exp));\n  shift = __fixmulShift;\n  return NativeMath.scalbn(<f64>significand, <i32>shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n  var sign = 1, magnitude = 0;\n  var code = <u32>load<u16>(ptr);\n  // check code is 'e' or 'E'\n  if ((code | 32) != CharCode.e) return 0;\n\n  code = <u32>load<u16>(ptr += 2);\n  if (code == CharCode.MINUS) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n  }\n  // skip zeros\n  while (code == CharCode._0) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n  }\n  for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n    if (magnitude >= 3200) return sign * 3200;\n    magnitude = 10 * magnitude + digit;\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy var __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n  var low  = (a & 0xFFFFFFFF) * b;\n  var high = (a >> 32) * b + (low >> 32);\n  var overflow = <u32>(high >> 32);\n  var space = clz(overflow);\n  var revspace: u64 = 32 - space;\n  __fixmulShift += revspace;\n  return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n  // argument `n` should bounds in [0, 22] range\n  return load<f64>(POWERS10 + (n << alignof<f64>()));\n}\n","/// <reference path=\"./rt/index.d.ts\" />\n\nimport { BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n  @lazy static readonly MAX_LENGTH: i32 = <i32>(BLOCK_MAXSIZE >>> alignof<u16>());\n\n  static fromCharCode(unit: i32, surr: i32 = -1): String {\n    var hasSur = surr > 0;\n    var out = __alloc(2 << i32(hasSur), idof<String>());\n    store<u16>(out, <u16>unit);\n    if (hasSur) store<u16>(out, <u16>surr, 2);\n    return changetype<String>(out); // retains\n  }\n\n  static fromCharCodes(units: Array<i32>): String {\n    var length = units.length;\n    var out = __alloc(<usize>length << 1, idof<String>());\n    var ptr = units.dataStart;\n    for (let i = 0; i < length; ++i) {\n      store<u16>(out + (<usize>i << 1), load<i32>(ptr + (<usize>i << 2)));\n    }\n    return changetype<String>(out);\n  }\n\n  static fromCodePoint(code: i32): String {\n    assert(<u32>code <= 0x10FFFF);\n    var hasSur = code > 0xFFFF;\n    var out = __alloc(2 << i32(hasSur), idof<String>());\n    if (!hasSur) {\n      store<u16>(out, <u16>code);\n    } else {\n      code -= 0x10000;\n      let hi = (code & 0x03FF) | 0xDC00;\n      let lo = (code >>> 10) | 0xD800;\n      store<u32>(out, lo | (hi << 16));\n    }\n    return changetype<String>(out); // retains\n  }\n\n  get length(): i32 {\n    return changetype<BLOCK>(changetype<usize>(this) - BLOCK_OVERHEAD).rtSize >> 1;\n  }\n\n  @operator(\"[]\") charAt(pos: i32): String {\n    if (<u32>pos >= <u32>this.length) return changetype<String>(\"\");\n    var out = __alloc(2, idof<String>());\n    store<u16>(out, load<u16>(changetype<usize>(this) + (<usize>pos << 1)));\n    return changetype<String>(out); // retains\n  }\n\n  charCodeAt(pos: i32): i32 {\n    if (<u32>pos >= <u32>this.length) return -1; // (NaN)\n    return load<u16>(changetype<usize>(this) + (<usize>pos << 1));\n  }\n\n  codePointAt(pos: i32): i32 {\n    var len = this.length;\n    if (<u32>pos >= <u32>len) return -1; // (undefined)\n    var first = <i32>load<u16>(changetype<usize>(this) + (<usize>pos << 1));\n    if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n    var second = <i32>load<u16>(changetype<usize>(this) + (<usize>pos << 1), 2);\n    if ((second & 0xFC00) != 0xDC00) return first;\n    return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n  }\n\n  @operator(\"+\") private static __concat(left: String, right: String): String {\n    return select<String>(left, changetype<String>(\"null\"), left !== null).concat(right);\n  }\n\n  concat(other: String): String {\n    if (other === null) other = changetype<String>(\"null\");\n    var thisSize: isize = this.length << 1;\n    var otherSize: isize = other.length << 1;\n    var outSize: usize = thisSize + otherSize;\n    if (outSize == 0) return changetype<String>(\"\");\n    var out = changetype<String>(__alloc(outSize, idof<String>())); // retains\n    memory.copy(changetype<usize>(out), changetype<usize>(this), thisSize);\n    memory.copy(changetype<usize>(out) + thisSize, changetype<usize>(other), otherSize);\n    return out;\n  }\n\n  endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n    if (search === null) return false;\n    end = min(max(end, 0), this.length);\n    var searchLength = <isize>search.length;\n    var searchStart = <isize>end - searchLength;\n    if (searchStart < 0) return false;\n    // @ts-ignore: string <-> String\n    return !compareImpl(this, searchStart, search, 0, searchLength);\n  }\n\n  @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n    if (left === right) return true;\n    if (left === null || right === null) return false;\n    var leftLength = left.length;\n    if (leftLength != right.length) return false;\n    // @ts-ignore: string <-> String\n    return !compareImpl(left, 0, right, 0, leftLength);\n  }\n\n  @operator.prefix(\"!\")\n  private static __not(str: String | null): bool {\n    return str === null || !str.length;\n  }\n\n  @operator(\"!=\")\n  private static __ne(left: String | null, right: String | null): bool {\n    return !this.__eq(left, right);\n  }\n\n  @operator(\">\") private static __gt(left: String | null, right: String | null): bool {\n    if (left === right || left === null || right === null) return false;\n    var leftLength  = left.length;\n    if (!leftLength) return false;\n    var rightLength = right.length;\n    if (!rightLength) return true;\n    // @ts-ignore: string <-> String\n    return compareImpl(left, 0, right, 0, min(leftLength, rightLength)) > 0;\n  }\n\n  @operator(\">=\") private static __gte(left: String, right: String): bool {\n    return !this.__lt(left, right);\n  }\n\n  @operator(\"<\") private static __lt(left: String, right: String): bool {\n    if (left === right || left === null || right === null) return false;\n    var rightLength = right.length;\n    if (!rightLength) return false;\n    var leftLength  = left.length;\n    if (!leftLength) return true;\n    // @ts-ignore: string <-> String\n    return compareImpl(left, 0, right, 0, min(leftLength, rightLength)) < 0;\n  }\n\n  @operator(\"<=\") private static __lte(left: String, right: String): bool {\n    return !this.__gt(left, right);\n  }\n\n  includes(search: String, start: i32 = 0): bool {\n    return this.indexOf(search, start) != -1;\n  }\n\n  indexOf(search: String, start: i32 = 0): i32 {\n    var searchLen = <isize>search.length;\n    if (!searchLen) return 0;\n    var len = <isize>this.length;\n    if (!len) return -1;\n    var searchStart = min(max(<isize>start, 0), len);\n    for (len -= searchLen; searchStart <= len; ++searchStart) {\n      // @ts-ignore: string <-> String\n      if (!compareImpl(this, searchStart, search, 0, searchLen)) return <i32>searchStart;\n    }\n    return -1;\n  }\n\n  lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n    var searchLen = <isize>search.length;\n    if (!searchLen) return this.length;\n    var len = this.length;\n    if (!len) return -1;\n    var searchStart = min(max(<isize>start, 0), <isize>len - searchLen);\n    for (; searchStart >= 0; --searchStart) {\n      // @ts-ignore: string <-> String\n      if (!compareImpl(this, searchStart, search, 0, searchLen)) return <i32>searchStart;\n    }\n    return -1;\n  }\n\n  // TODO: implement full locale comparison with locales and Collator options\n  localeCompare(other: String): i32 {\n    if (other === this) return 0; // compare pointers\n    var len: isize = this.length;\n    var otherLen: isize = other.length;\n    if (otherLen != len) return select(1, -1, len > otherLen);\n    if (!otherLen) return 0; // \"\" == \"\"\n    // @ts-ignore: string <-> String\n    return compareImpl(this, 0, other, 0, otherLen);\n  }\n\n  startsWith(search: String, start: i32 = 0): bool {\n    if (search === null) search = changetype<String>(\"null\");\n    var len = <isize>this.length;\n    var searchStart = min(max(<isize>start, 0), len);\n    var searchLength = <isize>search.length;\n    if (searchLength + searchStart > len) return false;\n    // @ts-ignore: string <-> String\n    return !compareImpl(this, searchStart, search, 0, searchLength);\n  }\n\n  substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n    var intStart: isize = start;\n    var end: isize = length;\n    var len: isize = this.length;\n    if (intStart < 0) intStart = max(len + intStart, 0);\n    var size = min(max(end, 0), len - intStart) << 1;\n    if (size <= 0) return changetype<String>(\"\");\n    var out = __alloc(size, idof<String>());\n    memory.copy(out, changetype<usize>(this) + (intStart << 1), size);\n    return changetype<String>(out); // retains\n  }\n\n  substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n    var len: isize = this.length;\n    var finalStart = min<isize>(max(start, 0), len);\n    var finalEnd = min<isize>(max(end, 0), len);\n    var fromPos = min<isize>(finalStart, finalEnd) << 1;\n    var toPos = max<isize>(finalStart, finalEnd) << 1;\n    var size = toPos - fromPos;\n    if (!size) return changetype<String>(\"\");\n    if (!fromPos && toPos == len << 1) return this;\n    var out = __alloc(size, idof<String>());\n    memory.copy(out, changetype<usize>(this) + fromPos, size);\n    return changetype<String>(out); // retains\n  }\n\n  trim(): String {\n    var len = this.length;\n    var size: usize = len << 1;\n    while (size && isSpace(load<u16>(changetype<usize>(this) + size - 2))) {\n      size -= 2;\n    }\n    var offset: usize = 0;\n    while (offset < size && isSpace(load<u16>(changetype<usize>(this) + offset))) {\n      offset += 2; size -= 2;\n    }\n    if (!size) return changetype<String>(\"\");\n    if (!offset && size == len << 1) return this;\n    var out = __alloc(size, idof<String>());\n    memory.copy(out, changetype<usize>(this) + offset, size);\n    return changetype<String>(out); // retains\n  }\n\n  @inline\n  trimLeft(): String {\n    return this.trimStart();\n  }\n\n  @inline\n  trimRight(): String {\n    return this.trimEnd();\n  }\n\n  trimStart(): String {\n    var size = <usize>this.length << 1;\n    var offset: usize = 0;\n    while (offset < size && isSpace(load<u16>(changetype<usize>(this) + offset))) {\n      offset += 2;\n    }\n    if (!offset) return this;\n    size -= offset;\n    if (!size) return changetype<String>(\"\");\n    var out = __alloc(size, idof<String>());\n    memory.copy(out, changetype<usize>(this) + offset, size);\n    return changetype<String>(out); // retains\n  }\n\n  trimEnd(): String {\n    var originalSize = <usize>this.length << 1;\n    var size = originalSize;\n    while (size && isSpace(load<u16>(changetype<usize>(this) + size - 2))) {\n      size -= 2;\n    }\n    if (!size) return changetype<String>(\"\");\n    if (size == originalSize) return this;\n    var out = __alloc(size, idof<String>());\n    memory.copy(out, changetype<usize>(this), size);\n    return changetype<String>(out); // retains\n  }\n\n  padStart(length: i32, pad: string = \" \"): String {\n    var thisSize = <usize>this.length << 1;\n    var targetSize = <usize>length << 1;\n    var padSize = <usize>pad.length << 1;\n    if (targetSize < thisSize || !padSize) return this;\n    var prependSize = targetSize - thisSize;\n    var out = __alloc(targetSize, idof<String>());\n    if (prependSize > padSize) {\n      let repeatCount = (prependSize - 2) / padSize;\n      let restBase = repeatCount * padSize;\n      let restSize = prependSize - restBase;\n      memory.repeat(out, changetype<usize>(pad), padSize, repeatCount);\n      memory.copy(out + restBase, changetype<usize>(pad), restSize);\n    } else {\n      memory.copy(out, changetype<usize>(pad), prependSize);\n    }\n    memory.copy(out + prependSize, changetype<usize>(this), thisSize);\n    return changetype<String>(out); //  retains\n  }\n\n  padEnd(length: i32, pad: string = \" \"): String {\n    var thisSize = <usize>this.length << 1;\n    var targetSize = <usize>length << 1;\n    var padSize = <usize>pad.length << 1;\n    if (targetSize < thisSize || !padSize) return this;\n    var appendSize = targetSize - thisSize;\n    var out = __alloc(targetSize, idof<String>());\n    memory.copy(out, changetype<usize>(this), thisSize);\n    if (appendSize > padSize) {\n      let repeatCount = (appendSize - 2) / padSize;\n      let restBase = repeatCount * padSize;\n      let restSize = appendSize - restBase;\n      memory.repeat(out + thisSize, changetype<usize>(pad), padSize, repeatCount);\n      memory.copy(out + thisSize + restBase, changetype<usize>(pad), restSize);\n    } else {\n      memory.copy(out + thisSize, changetype<usize>(pad), appendSize);\n    }\n    return changetype<String>(out); // retains\n  }\n\n  repeat(count: i32 = 0): String {\n    var length = this.length;\n\n    // Most browsers can't handle strings 1 << 28 chars or longer\n    if (count < 0 || <u64>length * count > (1 << 28)) {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n\n    if (count == 0 || !length) return changetype<String>(\"\");\n    if (count == 1) return this;\n    var out = __alloc((length * count) << 1, idof<String>());\n    memory.repeat(out, changetype<usize>(this), <usize>length << 1, count);\n    return changetype<String>(out); // retains\n  }\n\n  replace(search: String, replacement: String): String {\n    var len: usize = this.length;\n    var slen: usize = search.length;\n    if (len <= slen) {\n      return len < slen ? this : select<String>(replacement, this, search == this);\n    }\n    var index: isize = this.indexOf(search);\n    if (~index) {\n      let rlen: usize = replacement.length;\n      len -= slen;\n      let olen = len + rlen;\n      if (olen) {\n        let out = __alloc(olen << 1, idof<String>());\n        memory.copy(out, changetype<usize>(this), index << 1);\n        memory.copy(\n          out + (index << 1),\n          changetype<usize>(replacement),\n          rlen << 1\n        );\n        memory.copy(\n          out + ((index + rlen) << 1),\n          changetype<usize>(this) + ((index + slen) << 1),\n          (len - index) << 1\n        );\n        return changetype<String>(out);\n      }\n    }\n    return this;\n  }\n\n  replaceAll(search: String, replacement: String): String {\n    var len: usize = this.length;\n    var slen: usize = search.length;\n    if (len <= slen) {\n      return len < slen ? this : select<String>(replacement, this, search == this);\n    }\n    var rlen: usize = replacement.length;\n    if (!slen) {\n      if (!rlen) return this;\n      // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n      let out = __alloc((len + (len + 1) * rlen) << 1, idof<String>());\n      memory.copy(out, changetype<usize>(replacement), rlen << 1);\n      let offset = rlen;\n      for (let i: usize = 0; i < len; ++i) {\n        store<u16>(\n          changetype<usize>(out) + (offset++ << 1),\n          load<u16>(changetype<usize>(this) + (i << 1))\n        );\n        memory.copy(\n          out + (offset << 1),\n          changetype<usize>(replacement),\n          rlen << 1\n        );\n        offset += rlen;\n      }\n      return changetype<String>(out);\n    }\n    var prev: isize = 0, next: isize = 0;\n    if (slen == rlen) {\n      // Fast path when search and replacement have same length\n      let size = len << 1;\n      let out = __alloc(size, idof<String>());\n      memory.copy(out, changetype<usize>(this), size);\n      while (~(next = <isize>this.indexOf(search, <i32>prev))) {\n        memory.copy(out + (next << 1), changetype<usize>(replacement), rlen << 1);\n        prev = next + slen;\n      }\n      return changetype<String>(out);\n    }\n    var out: usize = 0, offset: usize = 0, resLen = len;\n    while (~(next = <isize>this.indexOf(search, <i32>prev))) {\n      if (!out) out = __alloc(len << 1, idof<String>());\n      if (offset > resLen) {\n        let newLength = resLen << 1;\n        out = __realloc(out, newLength << 1);\n        resLen = newLength;\n      }\n      let chunk = next - prev;\n      memory.copy(\n        out + (offset << 1),\n        changetype<usize>(this) + (prev << 1),\n        chunk << 1\n      );\n      offset += chunk;\n      memory.copy(\n        out + (offset << 1),\n        changetype<usize>(replacement),\n        rlen << 1\n      );\n      offset += rlen;\n      prev = next + slen;\n    }\n    if (offset) {\n      if (offset > resLen) {\n        let newLength = resLen << 1;\n        out = __realloc(out, newLength << 1);\n        resLen = newLength;\n      }\n      let rest = len - prev;\n      if (rest) {\n        memory.copy(\n          out + (offset << 1),\n          changetype<usize>(this) + (prev << 1),\n          rest << 1\n        );\n      }\n      rest += offset;\n      if (resLen > rest) out = __realloc(out, rest << 1);\n      return changetype<String>(out);\n    }\n    return this;\n  }\n\n  slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n    var len = this.length;\n    start = start < 0 ? max(start + len, 0) : min(start, len);\n    end   = end   < 0 ? max(end   + len, 0) : min(end,   len);\n    len   = end - start;\n    if (len <= 0) return changetype<String>(\"\");\n    var out = __alloc(len << 1, idof<String>());\n    memory.copy(out, changetype<usize>(this) + (<usize>start << 1), <usize>len << 1);\n    return changetype<String>(out); // retains\n  }\n\n  split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n    if (!limit) return changetype<Array<String>>(__allocArray(0, alignof<String>(), idof<Array<String>>())); // retains\n    if (separator === null) return [this];\n    var length: isize = this.length;\n    var sepLen = separator.length;\n    if (limit < 0) limit = i32.MAX_VALUE;\n    if (!sepLen) {\n      if (!length) return changetype<Array<String>>(__allocArray(0, alignof<String>(), idof<Array<String>>()));  // retains\n      // split by chars\n      length = min<isize>(length, <isize>limit);\n      let result = changetype<Array<String>>(__allocArray(<i32>length, alignof<String>(), idof<Array<String>>())); // retains\n      // @ts-ignore: cast\n      let resultStart = result.dataStart as usize;\n      for (let i: isize = 0; i < length; ++i) {\n        let charStr = __alloc(2, idof<String>());\n        store<u16>(charStr, load<u16>(changetype<usize>(this) + (<usize>i << 1)));\n        store<usize>(resultStart + (<usize>i << alignof<usize>()), charStr); // result[i] = charStr\n        if (isManaged<String>()) __retain(charStr);\n      }\n      return result;\n    } else if (!length) {\n      let result = changetype<Array<String>>(__allocArray(1, alignof<String>(), idof<Array<String>>())); // retains\n      // @ts-ignore: cast\n      store<usize>(result.dataStart as usize, changetype<usize>(\"\")); // static \"\"\n      return result;\n    }\n    var result = changetype<Array<String>>(__allocArray(0, alignof<String>(), idof<Array<String>>())); // retains\n    var end = 0, start = 0, i = 0;\n    while (~(end = this.indexOf(separator, start))) {\n      let len = end - start;\n      if (len > 0) {\n        let out = __alloc(<usize>len << 1, idof<String>());\n        memory.copy(out, changetype<usize>(this) + (<usize>start << 1), <usize>len << 1);\n        result.push(changetype<String>(out));\n      } else {\n        result.push(changetype<String>(\"\"));\n      }\n      if (++i == limit) return result;\n      start = end + sepLen;\n    }\n    if (!start) { // also means: loop above didn't do anything\n      result.push(this);\n      return result;\n    }\n    var len = length - start;\n    if (len > 0) {\n      let out = __alloc(<usize>len << 1, idof<String>());\n      memory.copy(out, changetype<usize>(this) + (<usize>start << 1), <usize>len << 1);\n      result.push(changetype<String>(out)); // retains\n    } else {\n      result.push(changetype<String>(\"\")); // static \"\"\n    }\n    return result;\n  }\n\n  toLowerCase(): String {\n    var len = <usize>this.length;\n    if (!len) return this;\n    var codes = __alloc(len * 2 * 2, idof<String>());\n    var j: usize = 0;\n    for (let i: usize = 0; i < len; ++i, ++j) {\n      let c = <u32>load<u16>(changetype<usize>(this) + (i << 1));\n      if (isAscii(c)) {\n        store<u16>(codes + (j << 1), toLower8(c));\n      } else {\n        // check and read surrogate pair\n        if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n          let c1 = <u32>load<u16>(changetype<usize>(this) + (i << 1), 2);\n          if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n            let c0 = c;\n            c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n            ++i;\n            if (c >= 0x20000) {\n              store<u32>(codes + (j << 1), c0 | (c1 << 16));\n              ++j;\n              continue;\n            }\n          }\n        }\n        // check special casing for lower table. It has one ently so instead lookup we just inline this.\n        if (c == 0x0130) {\n          // 0x0130 -> [0x0069, 0x0307]\n          store<u32>(codes + (j << 1), (0x0307 << 16) | 0x0069);\n          ++j;\n        } else if (c == 0x03A3) { // 'Σ'\n          // Σ maps to σ but except at the end of a word where it maps to ς\n          let sigma = 0x03C3; // σ\n          if (len > 1 && isFinalSigma(changetype<usize>(this), i, len)) {\n            sigma = 0x03C2; // ς\n          }\n          store<u16>(codes + (j << 1), sigma);\n        } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n          // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n          store<u16>(codes + (j << 1), c + 26);\n        } else {\n          let code = casemap(c, 0) & 0x1FFFFF;\n          if (code < 0x10000) {\n            store<u16>(codes + (j << 1), code);\n          } else {\n            // store as surrogare pair\n            code -= 0x10000;\n            let lo = (code >>> 10) | 0xD800;\n            let hi = (code & 0x03FF) | 0xDC00;\n            store<u32>(codes + (j << 1), lo | (hi << 16));\n            ++j;\n          }\n        }\n      }\n    }\n    codes = __realloc(codes, j << 1);\n    return changetype<String>(codes); // retains\n  }\n\n  toUpperCase(): String {\n    var len = <usize>this.length;\n    if (!len) return this;\n    var codes = __alloc(len * 3 * 2, idof<String>());\n    var specialsPtr = changetype<usize>(SPECIALS_UPPER);\n    var specialsLen = SPECIALS_UPPER.length;\n    var j: usize = 0;\n    for (let i: usize = 0; i < len; ++i, ++j) {\n      let c = <u32>load<u16>(changetype<usize>(this) + (i << 1));\n      if (isAscii(c)) {\n        store<u16>(codes + (j << 1), toUpper8(c));\n      } else {\n        // check and read surrogate pair\n        if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n          let c1 = <u32>load<u16>(changetype<usize>(this) + (i << 1), 2);\n          if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n            let c0 = c;\n            c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n            ++i;\n            if (c >= 0x20000) {\n              store<u32>(codes + (j << 1), c0 | (c1 << 16));\n              ++j;\n              continue;\n            }\n          }\n        }\n        // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n        if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n          // monkey patch\n          store<u16>(codes + (j << 1), c - 26);\n        } else {\n          let index: usize = -1;\n          // Fast range check. See first and last rows in specialsUpper table\n          if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n            index = <usize>bsearch(c, specialsPtr, specialsLen);\n          }\n          if (~index) {\n            // load next 3 code points from row with `index` offset for specialsUpper table\n            let ab = load<u32>(specialsPtr + (index << 1), 2);\n            let cc = load<u16>(specialsPtr + (index << 1), 6);\n            store<u32>(codes + (j << 1), ab, 0);\n            store<u16>(codes + (j << 1), cc, 4);\n            j += 1 + usize(cc != 0);\n          } else {\n            let code = casemap(c, 1) & 0x1FFFFF;\n            if (code < 0x10000) {\n              store<u16>(codes + (j << 1), code);\n            } else {\n              // store as surrogare pair\n              code -= 0x10000;\n              let lo = (code >>> 10) | 0xD800;\n              let hi = (code & 0x03FF) | 0xDC00;\n              store<u32>(codes + (j << 1), lo | (hi << 16));\n              ++j;\n            }\n          }\n        }\n      }\n    }\n    codes = __realloc(codes, j << 1);\n    return changetype<String>(codes); // retains\n  }\n\n  toString(): String {\n    return this;\n  }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n  return strtol<f64>(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n  return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n  export namespace UTF8 {\n\n    export function byteLength(str: string, nullTerminated: bool = false): i32 {\n      var strOff = changetype<usize>(str);\n      var strEnd = strOff + <usize>changetype<BLOCK>(changetype<usize>(str) - BLOCK_OVERHEAD).rtSize;\n      var bufLen = i32(nullTerminated);\n      while (strOff < strEnd) {\n        let c1 = <u32>load<u16>(strOff);\n        if (c1 < 128) {\n          // @ts-ignore: cast\n          if (nullTerminated & !c1) break;\n          bufLen += 1;\n        } else if (c1 < 2048) {\n          bufLen += 2;\n        } else {\n          if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n            if ((<u32>load<u16>(strOff, 2) & 0xFC00) == 0xDC00) {\n              bufLen += 4; strOff += 4;\n              continue;\n            }\n          }\n          bufLen += 3;\n        }\n        strOff += 2;\n      }\n      return bufLen;\n    }\n\n    export function encode(str: string, nullTerminated: bool = false): ArrayBuffer {\n      var buf = __alloc(<usize>byteLength(str, nullTerminated), idof<ArrayBuffer>());\n      encodeUnsafe(changetype<usize>(str), str.length, buf, nullTerminated);\n      return changetype<ArrayBuffer>(buf); // retains\n    }\n\n    // @ts-ignore: decorator\n    @unsafe\n    export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false): usize {\n      var strEnd = str + (<usize>len << 1);\n      var bufOff = buf;\n      while (str < strEnd) {\n        let c1 = <u32>load<u16>(str);\n        if (c1 < 128) {\n          store<u8>(bufOff, c1);\n          bufOff++;\n        } else if (c1 < 2048) {\n          let b0 = c1 >> 6 | 192;\n          let b1 = c1 & 63 | 128;\n          store<u16>(bufOff, b1 << 8 | b0);\n          bufOff += 2;\n        } else {\n          if ((c1 & 0xFC00) == 0xD800 && str + 2 < strEnd) {\n            let c2 = <u32>load<u16>(str, 2);\n            if ((c2 & 0xFC00) == 0xDC00) {\n              c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n              let b0 = c1 >> 18 | 240;\n              let b1 = c1 >> 12 & 63 | 128;\n              let b2 = c1 >> 6  & 63 | 128;\n              let b3 = c1       & 63 | 128;\n              store<u32>(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n              bufOff += 4; str += 4;\n              continue;\n            }\n          }\n          let b0 = c1 >> 12 | 224;\n          let b1 = c1 >> 6  & 63 | 128;\n          let b2 = c1       & 63 | 128;\n          store<u16>(bufOff, b1 << 8 | b0);\n          store<u8>(bufOff, b2, 2);\n          bufOff += 3;\n        }\n        str += 2;\n      }\n      if (nullTerminated) {\n        store<u8>(bufOff++, 0);\n      }\n      return bufOff - buf;\n    }\n\n    export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n      return decodeUnsafe(changetype<usize>(buf), buf.byteLength, nullTerminated);\n    }\n\n    // @ts-ignore: decorator\n    @unsafe\n    export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n      var bufOff = buf;\n      var bufEnd = buf + len;\n      assert(bufEnd >= bufOff); // guard wraparound\n      var str = __alloc(len << 1, idof<String>()); // max is one u16 char per u8 byte\n      var strOff = str;\n      while (bufOff < bufEnd) {\n        let u0 = <u32>load<u8>(bufOff); ++bufOff;\n        if (!(u0 & 128)) {\n          // @ts-ignore: cast\n          if (nullTerminated & !u0) break;\n          store<u16>(strOff, u0);\n        } else {\n          if (bufEnd == bufOff) break;\n          let u1 = <u32>load<u8>(bufOff) & 63; ++bufOff;\n          if ((u0 & 224) == 192) {\n            store<u16>(strOff, (u0 & 31) << 6 | u1);\n          } else {\n            if (bufEnd == bufOff) break;\n            let u2 = <u32>load<u8>(bufOff) & 63; ++bufOff;\n            if ((u0 & 240) == 224) {\n              u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n            } else {\n              if (bufEnd == bufOff) break;\n              u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | <u32>load<u8>(bufOff) & 63;\n              ++bufOff;\n            }\n            if (u0 < 0x10000) {\n              store<u16>(strOff, u0);\n            } else {\n              u0 -= 0x10000;\n              let lo = u0 >> 10 | 0xD800;\n              let hi = (u0 & 0x03FF) | 0xDC00;\n              store<u32>(strOff, lo | (hi << 16));\n              strOff += 2;\n            }\n          }\n        }\n        strOff += 2;\n      }\n      return changetype<String>(__realloc(str, strOff - str)); // retains\n    }\n  }\n\n  export namespace UTF16 {\n\n    export function byteLength(str: string): i32 {\n      return changetype<BLOCK>(changetype<usize>(str) - BLOCK_OVERHEAD).rtSize;\n    }\n\n    export function encode(str: string): ArrayBuffer {\n      var buf = __alloc(<usize>byteLength(str), idof<ArrayBuffer>());\n      encodeUnsafe(changetype<usize>(str), str.length, buf);\n      return changetype<ArrayBuffer>(buf); // retains\n    }\n\n    // @ts-ignore: decorator\n    @unsafe\n    export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n      var size = <usize>len << 1;\n      memory.copy(buf, changetype<usize>(str), size);\n      return size;\n    }\n\n    export function decode(buf: ArrayBuffer): String {\n      return decodeUnsafe(changetype<usize>(buf), buf.byteLength);\n    }\n\n    // @ts-ignore: decorator\n    @unsafe\n    export function decodeUnsafe(buf: usize, len: usize): String {\n      var str = __alloc(len &= ~1, idof<String>());\n      memory.copy(str, buf, len);\n      return changetype<String>(str); // retains\n    }\n  }\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n  /** Gets the size of the memory in pages. */\n  // @ts-ignore: decorator\n  @builtin\n  export declare function size(): i32;\n\n  /** Grows the memory by the given size in pages and returns the previous size in pages. */\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function grow(pages: i32): i32;\n\n  /** Fills a section in memory with the specified byte value. */\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export function fill(dst: usize, c: u8, n: usize): void {\n    memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n  }\n\n  /** Copies a section of memory to another. Has move semantics. */\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export function copy(dst: usize, src: usize, n: usize): void {\n    memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n  }\n\n  /** Initializes a memory segment. */\n  // @ts-ignore: decorator\n  @unsafe\n  export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n    throw new Error(E_NOTIMPLEMENTED);\n  }\n\n  /** Drops a memory segment. */\n  // @ts-ignore: decorator\n  @unsafe\n  export function drop(segmentIndex: u32): void {\n    throw new Error(E_NOTIMPLEMENTED);\n  }\n\n  /** Repeats a section of memory at a specific address. */\n  // @ts-ignore: decorator\n  @unsafe\n  export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n    var index: usize = 0;\n    var total = srcLength * count;\n    while (index < total) {\n      memory.copy(dst + index, src, srcLength);\n      index += srcLength;\n    }\n  }\n\n  /** Compares a section of memory to another. */\n  // @ts-ignore: decorator\n  @inline\n  export function compare(vl: usize, vr: usize, n: usize): i32 {\n    return memcmp(vl, vr, n);\n  }\n\n  /** Gets a pointer to a static chunk of memory of the given size. */\n  // @ts-ignore: decorator\n  @builtin\n  export declare function data<T>(size: T, align?: i32): usize;\n}\n","export function memcpy(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memcpy.c\n  var w: u32, x: u32;\n\n  // copy 1 byte each until src is aligned to 4 bytes\n  while (n && (src & 3)) {\n    store<u8>(dest++, load<u8>(src++));\n    n--;\n  }\n\n  // if dst is aligned to 4 bytes as well, copy 4 bytes each\n  if ((dest & 3) == 0) {\n    while (n >= 16) {\n      store<u32>(dest     , load<u32>(src     ));\n      store<u32>(dest +  4, load<u32>(src +  4));\n      store<u32>(dest +  8, load<u32>(src +  8));\n      store<u32>(dest + 12, load<u32>(src + 12));\n      src += 16; dest += 16; n -= 16;\n    }\n    if (n & 8) {\n      store<u32>(dest    , load<u32>(src    ));\n      store<u32>(dest + 4, load<u32>(src + 4));\n      dest += 8; src += 8;\n    }\n    if (n & 4) {\n      store<u32>(dest, load<u32>(src));\n      dest += 4; src += 4;\n    }\n    if (n & 2) { // drop to 2 bytes each\n      store<u16>(dest, load<u16>(src));\n      dest += 2; src += 2;\n    }\n    if (n & 1) { // drop to 1 byte\n      store<u8>(dest++, load<u8>(src++));\n    }\n    return;\n  }\n\n  // if dst is not aligned to 4 bytes, use alternating shifts to copy 4 bytes each\n  // doing shifts if faster when copying enough bytes (here: 32 or more)\n  if (n >= 32) {\n    switch (<u32>dest & 3) {\n      // known to be != 0\n      case 1: {\n        w = load<u32>(src);\n        store<u8>(dest++, load<u8>(src++));\n        store<u8>(dest++, load<u8>(src++));\n        store<u8>(dest++, load<u8>(src++));\n        n -= 3;\n        while (n >= 17) {\n          x = load<u32>(src + 1);\n          store<u32>(dest, w >> 24 | x << 8);\n          w = load<u32>(src + 5);\n          store<u32>(dest + 4, x >> 24 | w << 8);\n          x = load<u32>(src + 9);\n          store<u32>(dest + 8, w >> 24 | x << 8);\n          w = load<u32>(src + 13);\n          store<u32>(dest + 12, x >> 24 | w << 8);\n          src += 16; dest += 16; n -= 16;\n        }\n        break;\n      }\n      case 2: {\n        w = load<u32>(src);\n        store<u8>(dest++, load<u8>(src++));\n        store<u8>(dest++, load<u8>(src++));\n        n -= 2;\n        while (n >= 18) {\n          x = load<u32>(src + 2);\n          store<u32>(dest, w >> 16 | x << 16);\n          w = load<u32>(src + 6);\n          store<u32>(dest + 4, x >> 16 | w << 16);\n          x = load<u32>(src + 10);\n          store<u32>(dest + 8, w >> 16 | x << 16);\n          w = load<u32>(src + 14);\n          store<u32>(dest + 12, x >> 16 | w << 16);\n          src += 16; dest += 16; n -= 16;\n        }\n        break;\n      }\n      case 3: {\n        w = load<u32>(src);\n        store<u8>(dest++, load<u8>(src++));\n        n -= 1;\n        while (n >= 19) {\n          x = load<u32>(src + 3);\n          store<u32>(dest, w >> 8 | x << 24);\n          w = load<u32>(src + 7);\n          store<u32>(dest + 4, x >> 8 | w << 24);\n          x = load<u32>(src + 11);\n          store<u32>(dest + 8, w >> 8 | x << 24);\n          w = load<u32>(src + 15);\n          store<u32>(dest + 12, x >> 8 | w << 24);\n          src += 16; dest += 16; n -= 16;\n        }\n        break;\n      }\n    }\n  }\n\n  // copy remaining bytes one by one\n  if (n & 16) {\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n  }\n  if (n & 8) {\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n  }\n  if (n & 4) {\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n  }\n  if (n & 2) {\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n  }\n  if (n & 1) {\n    store<u8>(dest++, load<u8>(src++));\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function memmove(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memmove.c\n  if (dest === src) return;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (src + n <= dest || dest + n <= src) {\n      memcpy(dest, src, n);\n      return;\n    }\n  }\n  if (dest < src) {\n    if (ASC_SHRINK_LEVEL < 2) {\n      if ((src & 7) == (dest & 7)) {\n        while (dest & 7) {\n          if (!n) return;\n          --n;\n          store<u8>(dest++, load<u8>(src++));\n        }\n        while (n >= 8) {\n          store<u64>(dest, load<u64>(src));\n          n    -= 8;\n          dest += 8;\n          src  += 8;\n        }\n      }\n    }\n    while (n) {\n      store<u8>(dest++, load<u8>(src++));\n      --n;\n    }\n  } else {\n    if (ASC_SHRINK_LEVEL < 2) {\n      if ((src & 7) == (dest & 7)) {\n        while ((dest + n) & 7) {\n          if (!n) return;\n          store<u8>(dest + --n, load<u8>(src + n));\n        }\n        while (n >= 8) {\n          n -= 8;\n          store<u64>(dest + n, load<u64>(src + n));\n        }\n      }\n    }\n    while (n) {\n      store<u8>(dest + --n, load<u8>(src + n));\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function memset(dest: usize, c: u8, n: usize): void { // see: musl/src/string/memset\n  if (ASC_SHRINK_LEVEL > 1) {\n    while (n) {\n      store<u8>(dest++, c);\n      --n;\n    }\n  } else {\n    // fill head and tail with minimal branching\n    if (!n) return;\n    let dend = dest + n - 4;\n    store<u8>(dest, c);\n    store<u8>(dend, c, 3);\n    if (n <= 2) return;\n    store<u8>(dest, c, 1);\n    store<u8>(dest, c, 2);\n    store<u8>(dend, c, 2);\n    store<u8>(dend, c, 1);\n    if (n <= 6) return;\n    store<u8>(dest, c, 3);\n    store<u8>(dend, c);\n    if (n <= 8) return;\n\n    // advance pointer to align it at 4-byte boundary\n    let k: usize = -dest & 3;\n    dest += k;\n    n -= k;\n    n &= -4;\n\n    let c32: u32 = <u32>-1 / 255 * c;\n\n    // fill head/tail up to 28 bytes each in preparation\n    dend = dest + n - 28;\n    store<u32>(dest, c32);\n    store<u32>(dend, c32, 24);\n    if (n <= 8) return;\n    store<u32>(dest, c32, 4);\n    store<u32>(dest, c32, 8);\n    store<u32>(dend, c32, 16);\n    store<u32>(dend, c32, 20);\n    if (n <= 24) return;\n    store<u32>(dest, c32, 12);\n    store<u32>(dest, c32, 16);\n    store<u32>(dest, c32, 20);\n    store<u32>(dest, c32, 24);\n    store<u32>(dend, c32);\n    store<u32>(dend, c32, 4);\n    store<u32>(dend, c32, 8);\n    store<u32>(dend, c32, 12);\n\n    // align to a multiple of 8\n    k = 24 + (dest & 4);\n    dest += k;\n    n -= k;\n\n    // copy 32 bytes each\n    let c64: u64 = <u64>c32 | (<u64>c32 << 32);\n    while (n >= 32) {\n      store<u64>(dest, c64);\n      store<u64>(dest, c64, 8);\n      store<u64>(dest, c64, 16);\n      store<u64>(dest, c64, 24);\n      n -= 32;\n      dest += 32;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function memcmp(vl: usize, vr: usize, n: usize): i32 {\n  if (vl == vr) return 0;\n  if (ASC_SHRINK_LEVEL < 2) {\n    if ((vl & 7) == (vr & 7)) {\n      while (vl & 7) {\n        if (!n) return 0;\n        let a = <i32>load<u8>(vl);\n        let b = <i32>load<u8>(vr);\n        if (a != b) return a - b;\n        n--; vl++; vr++;\n      }\n      while (n >= 8) {\n        if (load<u64>(vl) != load<u64>(vr)) break;\n        vl += 8;\n        vr += 8;\n        n  -= 8;\n      }\n    }\n  }\n  while (n--) {\n    let a = <i32>load<u8>(vl);\n    let b = <i32>load<u8>(vr);\n    if (a != b) return a - b;\n    vl++; vr++;\n  }\n  return 0;\n}\n","// Common error messages for use accross the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0;\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN<T extends number>(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite<T extends number>(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): i8 {\n    return <i8>strtol<i32>(value, radix);\n  }\n\n  toString(this: i8, radix: i32 = 10): String {\n    return itoa32(this, radix);\n  }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): i16 {\n    return <i16>strtol<i32>(value, radix);\n  }\n\n  toString(this: i16, radix: i32 = 10): String {\n    return itoa32(this, radix);\n  }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): i32 {\n    return <i32>strtol<i32>(value, radix);\n  }\n\n  toString(this: i32, radix: i32 = 10): String {\n    return itoa32(this, radix);\n  }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): i64 {\n    return strtol<i64>(value, radix);\n  }\n\n  toString(this: i64, radix: i32 = 10): String {\n    return itoa64(this, radix);\n  }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): isize {\n    return <isize>strtol<i64>(value, radix);\n  }\n\n  toString(this: isize, radix: i32 = 10): String {\n    if (sizeof<isize>() == 4) {\n      return itoa32(this, radix);\n    } else {\n      return itoa64(this, radix);\n    }\n  }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): u8 {\n    return <u8>strtol<i32>(value, radix);\n  }\n\n  toString(this: u8, radix: i32 = 10): String {\n    return utoa32(this, radix);\n  }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): u16 {\n    return <u16>strtol<i32>(value, radix);\n  }\n\n  toString(this: u16, radix: i32 = 10): String {\n    return utoa32(this, radix);\n  }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): u32 {\n    return <u32>strtol<i32>(value, radix);\n  }\n\n  toString(this: u32, radix: i32 = 10): String {\n    return utoa32(this, radix);\n  }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): u64 {\n    return <u64>strtol<i64>(value, radix);\n  }\n\n  toString(this: u64, radix: i32 = 10): String {\n    return utoa64(this, radix);\n  }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n  static parseInt(value: string, radix: i32 = 0): usize {\n    return <usize>strtol<i64>(value, radix);\n  }\n\n  toString(this: usize, radix: i32 = 10): String {\n    if (sizeof<isize>() == 4) {\n      return utoa32(this, radix);\n    } else {\n      return utoa64(this, radix);\n    }\n  }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n  toString(this: bool, radix: i32 = 0): String {\n    return this ? \"true\" : \"false\";\n  }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly EPSILON: f32 = f32.EPSILON;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly POSITIVE_INFINITY: f32 = Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly NEGATIVE_INFINITY: f32 = -Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly NaN: f32 = NaN;\n\n  static isNaN(value: f32): bool {\n    return isNaN<f32>(value);\n  }\n\n  static isFinite(value: f32): bool {\n    return isFinite<f32>(value);\n  }\n\n  static isSafeInteger(value: f32): bool {\n    return abs<f32>(value) <= f32.MAX_SAFE_INTEGER && trunc<f32>(value) == value;\n  }\n\n  static isInteger(value: f32): bool {\n    return isFinite<f32>(value) && trunc<f32>(value) == value;\n  }\n\n  static parseInt(value: string, radix: i32 = 0): f32 {\n    return <f32>strtol<i64>(value, radix);\n  }\n\n  static parseFloat(value: string): f32 {\n    return <f32>parseFloat(value);\n  }\n\n  toString(this: f32, radix: i32 = 0): String {\n    return dtoa(this);\n  }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly EPSILON: f64 = f64.EPSILON;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly POSITIVE_INFINITY: f64 = Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly NEGATIVE_INFINITY: f64 = -Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly NaN: f64 = NaN;\n\n  static isNaN(value: f64): bool {\n    return isNaN<f64>(value);\n  }\n\n  static isFinite(value: f64): bool {\n    return isFinite<f64>(value);\n  }\n\n  static isSafeInteger(value: f64): bool {\n    return abs<f64>(value) <= f64.MAX_SAFE_INTEGER && trunc<f64>(value) == value;\n  }\n\n  static isInteger(value: f64): bool {\n    return isFinite<f64>(value) && trunc<f64>(value) == value;\n  }\n\n  static parseInt(value: string, radix: i32 = 0): f64 {\n    return <f64>strtol<i64>(value, radix);\n  }\n\n  static parseFloat(value: string): f64 {\n    return parseFloat(value);\n  }\n\n  toString(this: f64, radix: i32 = 0): String {\n    return dtoa(this);\n  }\n}\n\nexport { F64 as Number };\n","type auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid<T>(): boolean;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof<T>(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl<T>(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr<T>(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret<T>(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc<T>(value: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load<T>(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store<T>(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof<T>(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof<T>(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof<T>(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof<T>(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype<T>(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert<T>(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked<T>(expr: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate<T>(...args: auto[]): T;\n\nexport namespace atomic {\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load<T>(ptr: usize, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store<T>(ptr: usize, value: T, immOffset?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function and<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function or<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function xor<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function notify(ptr: usize, count: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n  OK = 0,\n  NOT_EQUAL = 1,\n  TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i8 = -128;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i8 =  127;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i16 = -32768;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i16 =  32767;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i32 = -2147483648;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i32 =  2147483647;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function clz(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ctz(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotl(value: i32, shift: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotr(value: i32, shift: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_f32(value: f32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  export namespace atomic {\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function wait(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n    export namespace rmw8 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n\n    export namespace rmw16 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n\n    export namespace rmw {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i64 = -9223372036854775808;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i64 =  9223372036854775807;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function clz(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ctz(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotl(value: i64, shift: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotr(value: i64, shift: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_f64(value: f64): i64;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  export namespace atomic {\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function wait(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n\n    export namespace rmw8 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw16 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw32 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: isize = sizeof<i32>() == sizeof<isize>()\n    ? -2147483648\n    : <isize>-9223372036854775808;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: isize = sizeof<i32>() == sizeof<isize>()\n    ? 2147483647\n    : <isize>9223372036854775807;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u8 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u8 = 255;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u16 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u16 = 65535;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u32 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u32 = 4294967295;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u64 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u64 = 18446744073709551615;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: usize = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: usize = sizeof<u32>() == sizeof<usize>()\n    ? 4294967295\n    : <usize>18446744073709551615;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: bool = false;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: bool = true;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const EPSILON = reinterpret<f32>(0x34000000); // 0x1p-23f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE = reinterpret<f32>(0x00000001); // 0x0.000001p+0f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE = reinterpret<f32>(0x7F7FFFFF); // 0x1.fffffep+127f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_NORMAL_VALUE = reinterpret<f32>(0x00800000); // 0x1p-126f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_SAFE_INTEGER: f32 =  16777215;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function copysign(x: f32, y: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_i32(value: i32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(value: f32): f32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const EPSILON = reinterpret<f64>(0x3CB0000000000000); // 0x1p-52\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE = reinterpret<f64>(0x0000000000000001); // 0x0.0000000000001p+0\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE = reinterpret<f64>(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_NORMAL_VALUE = reinterpret<f64>(0x0010000000000000); // 0x1p-1022\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_SAFE_INTEGER: f64 =  9007199254740991;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function copysign(x: f64, y: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_i64(value: i64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(value: f64): f64;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n  a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n  i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat<T>(x: T): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane<T>(x: v128, idx: u8): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane<T>(x: v128, idx: u8, value: T): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function swizzle(a: v128, s: v128): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_splat<T>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_ext<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul<T>(a: v128, b: v128): v128; // except i64\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div<T>(a: v128, b: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_saturate<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_saturate<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl<T>(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr<T>(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function and(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function or(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function xor(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function andnot(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function not(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function any_true<T>(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true<T>(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask<T>(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function dot<T>(a: v128, b: v128): v128; // i16 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr<T>(a: v128, b: v128): v128; // u8, u16 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_low<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_high<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function qfma<T>(v1: v128, v2: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function qfms<T>(v1: v128, v2: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n  a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n  i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_saturate_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_saturate_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_saturate_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_saturate_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function any_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i16): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_saturate_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_saturate_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_saturate_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_saturate_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function any_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_low_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_low_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_high_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_high_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function any_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_low_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_low_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_high_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function widen_high_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function any_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f64x2_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f64x2_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: f32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function qfma(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function qfms(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: f64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i64x2_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i64x2_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function qfma(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function qfms(a: v128, b: v128, c: v128): v128;\n}\n\nexport namespace v8x16 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(\n    a: v128, b: v128,\n    l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n    l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n  ): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function swizzle(a: v128, s: v128): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n}\n\nexport namespace v16x8 {\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n}\n\nexport namespace v32x4 {\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n}\n\nexport namespace v64x2 {\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n}\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\ndeclare function abort(\n  message?: string | null,\n  fileName?: string | null,\n  lineNumber?: u32,\n  columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\ndeclare function trace(\n  message: string,\n  n?: i32,\n  a0?: f64,\n  a1?: f64,\n  a2?: f64,\n  a3?: f64,\n  a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\ndeclare function seed(): f64;\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport ByteBuffer from \"./ByteBuffer\";\nimport Histogram from \"./Histogram\";\nimport ZigZagEncoding from \"./ZigZagEncoding\";\n\nconst V2EncodingCookieBase = 0x1c849303;\nconst V2CompressedEncodingCookieBase = 0x1c849304;\nconst V2maxWordSizeInBytes = 9; // LEB128-64b9B + ZigZag require up to 9 bytes per word\nconst encodingCookie = V2EncodingCookieBase | 0x10; // LSBit of wordsize byte indicates TLZE Encoding\nconst compressedEncodingCookie = V2CompressedEncodingCookieBase | 0x10; // LSBit of wordsize byte indicates TLZE Encoding\n\nfunction fillBufferFromCountsArray<T, U>(\n  self: Histogram<T, U>,\n  buffer: ByteBuffer\n): void {\n  const countsLimit = self.countsArrayIndex(self.maxValue) + 1;\n  let srcIndex = 0;\n\n  while (srcIndex < countsLimit) {\n    // V2 encoding format uses a ZigZag LEB128-64b9B encoded long. Positive values are counts,\n    // while negative values indicate a repeat zero counts.\n    const count = self.getCountAtIndex(srcIndex++);\n    if (count < 0) {\n      throw new Error(\n        \"Cannot encode histogram containing negative counts (\" +\n          count.toString() +\n          \") at index \" +\n          srcIndex.toString() +\n          \", corresponding the value range [\" +\n          self.lowestEquivalentValue(self.valueFromIndex(srcIndex)).toString() +\n          \",\" +\n          self\n            .nextNonEquivalentValue(self.valueFromIndex(srcIndex))\n            .toString() +\n          \")\"\n      );\n    }\n    // Count trailing 0s (which follow this count):\n    let zerosCount = 0;\n    if (count == 0) {\n      zerosCount = 1;\n      while (srcIndex < countsLimit && self.getCountAtIndex(srcIndex) == 0) {\n        zerosCount++;\n        srcIndex++;\n      }\n    }\n    if (zerosCount > 1) {\n      ZigZagEncoding.encode(buffer, -zerosCount);\n    } else {\n      ZigZagEncoding.encode(buffer, count);\n    }\n  }\n}\n\n/**\n * Encode this histogram into a ByteBuffer\n * @param buffer The buffer to encode into\n * @return The number of bytes written to the buffer\n */\nexport function encodeIntoByteBuffer<T, U>(\n  self: Histogram<T, U>,\n  buffer: ByteBuffer\n): i32 {\n  const initialPosition = buffer.position;\n  buffer.putInt32(encodingCookie);\n  buffer.putInt32(0); // Placeholder for payload length in bytes.\n  buffer.putInt32(1);\n  buffer.putInt32(self.numberOfSignificantValueDigits);\n  buffer.putInt64(self.lowestDiscernibleValue);\n  buffer.putInt64(self.highestTrackableValue);\n  buffer.putInt64(1);\n\n  const payloadStartPosition = buffer.position;\n  fillBufferFromCountsArray(self, buffer);\n\n  const backupIndex = buffer.position;\n  buffer.position = initialPosition + 4;\n  buffer.putInt32(backupIndex - payloadStartPosition); // Record the payload length\n\n  buffer.position = backupIndex;\n\n  return backupIndex - initialPosition;\n}\n\nfunction fillCountsArrayFromSourceBuffer<T, U>(\n  self: Histogram<T, U>,\n  sourceBuffer: ByteBuffer,\n  lengthInBytes: u32,\n  wordSizeInBytes: u32\n): i32 {\n  if (\n    wordSizeInBytes != 2 &&\n    wordSizeInBytes != 4 &&\n    wordSizeInBytes != 8 &&\n    wordSizeInBytes != V2maxWordSizeInBytes\n  ) {\n    throw new Error(\n      \"word size must be 2, 4, 8, or V2maxWordSizeInBytes (\" +\n        V2maxWordSizeInBytes.toString() +\n        \") bytes\"\n    );\n  }\n  let dstIndex: i32 = 0;\n  const endPosition = sourceBuffer.position + lengthInBytes;\n  while (sourceBuffer.position < endPosition) {\n    let zerosCount: i32 = 0;\n    let count = <i32>ZigZagEncoding.decode(sourceBuffer);\n    if (count < 0) {\n      zerosCount = -count;\n      dstIndex += zerosCount; // No need to set zeros in array. Just skip them.\n    } else {\n      self.setCountAtIndex(dstIndex++, count);\n    }\n  }\n  return dstIndex; // this is the destination length\n}\n\nfunction getCookieBase(cookie: u32): u32 {\n  return cookie & ~0xf0;\n}\n\nfunction getWordSizeInBytesFromCookie(cookie: u32): u32 {\n  if (\n    getCookieBase(cookie) == V2EncodingCookieBase ||\n    getCookieBase(cookie) == V2CompressedEncodingCookieBase\n  ) {\n    return V2maxWordSizeInBytes;\n  }\n  const sizeByte = (cookie & 0xf0) >> 4;\n  return sizeByte & 0xe;\n}\n\nexport function decodeFromByteBuffer<T, U>(\n  buffer: ByteBuffer,\n  minBarForHighestTrackableValue: u64\n): Histogram<T, U> {\n  const cookie = buffer.getInt32();\n\n  let payloadLengthInBytes: u32;\n  let numberOfSignificantValueDigits: u8;\n  let lowestTrackableUnitValue: u64;\n  let highestTrackableValue: u64;\n\n  if (getCookieBase(cookie) === V2EncodingCookieBase) {\n    if (getWordSizeInBytesFromCookie(cookie) != V2maxWordSizeInBytes) {\n      throw new Error(\n        \"The buffer does not contain a Histogram (no valid cookie found)\"\n      );\n    }\n    payloadLengthInBytes = buffer.getInt32();\n    buffer.getInt32(); // normalizingIndexOffset not used\n    numberOfSignificantValueDigits = <u8>buffer.getInt32();\n    lowestTrackableUnitValue = buffer.getInt64();\n    highestTrackableValue = buffer.getInt64();\n    buffer.getInt64(); // integerToDoubleValueConversionRatio not used\n  } else {\n    throw new Error(\n      \"The buffer does not contain a Histogram (no valid V2 encoding cookie found)\"\n    );\n  }\n\n  highestTrackableValue = max(\n    highestTrackableValue,\n    minBarForHighestTrackableValue\n  );\n\n  const histogram: Histogram<T, U> = instantiate<Histogram<T, U>>(\n    lowestTrackableUnitValue,\n    highestTrackableValue,\n    numberOfSignificantValueDigits\n  );\n\n  const filledLength = fillCountsArrayFromSourceBuffer(\n    histogram,\n    buffer,\n    payloadLengthInBytes,\n    V2maxWordSizeInBytes\n  );\n\n  histogram.establishInternalTackingValues(filledLength);\n\n  return histogram;\n}\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nexport const bitCount = (n: u64): u8 => {\n  let bits: u8 = 0;\n  while (n !== 0) {\n    const input: u32 = <u32>(n & (<u64>u32.MAX_VALUE));\n    bits += bitCount32(input);\n    n /= 0x100000000;\n  }\n  return bits;\n};\n\nfunction bitCount32(input: u32): u8 {\n  let n = input;\n  n = n - ((n >> 1) & 0x55555555);\n  n = (n & 0x33333333) + ((n >> 2) & 0x33333333);\n  return <u8>((((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24);\n}\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport { bitCount } from \"./bitcount\";\n\n/**\n * A packed-value, sparse array context used for storing 64 bit signed values.\n *\n * An array context is optimised for tracking sparsely set (as in mostly zeros) values that tend to not make\n * use pof the full 64 bit value range even when they are non-zero. The array context's internal representation\n * is such that the packed value at each virtual array index may be represented by 0-8 bytes of actual storage.\n *\n * An array context encodes the packed values in 8 \"set trees\" with each set tree representing one byte of the\n * packed value at the virtual index in question. The {@link #getPackedIndex(int, int, boolean)} method is used\n * to look up the byte-index corresponding to the given (set tree) value byte of the given virtual index, and can\n * be used to add entries to represent that byte as needed. As a succesful {@link #getPackedIndex(int, int, boolean)}\n * may require a resizing of the array, it can throw a {@link ResizeError} to indicate that the requested\n * packed index cannot be found or added without a resize of the physical storage.\n *\n */\nexport const MINIMUM_INITIAL_PACKED_ARRAY_CAPACITY = 16;\nconst MAX_SUPPORTED_PACKED_COUNTS_ARRAY_LENGTH = Math.pow(2, 13) - 1; //(Short.MAX_VALUE / 4);  TODO ALEX why ???\nconst SET_0_START_INDEX = 0;\nconst NUMBER_OF_SETS = 8;\nconst LEAF_LEVEL_SHIFT = 3;\nconst NON_LEAF_ENTRY_SLOT_INDICATORS_OFFSET = 0;\nconst NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS = <u16>1;\nconst PACKED_ARRAY_GROWTH_INCREMENT = 16;\nconst PACKED_ARRAY_GROWTH_FRACTION_POW2 = 4;\n\nexport class PackedArrayContext {\n  public readonly isPacked: boolean;\n  physicalLength: i32;\n\n  private array: ArrayBuffer;\n  private byteArray: Uint8Array;\n  private shortArray: Uint16Array;\n  private longArray: Uint64Array;\n  private populatedShortLength: i32 = 0;\n  private virtualLength: i32;\n  private topLevelShift: i32 = i32.MAX_VALUE; // Make it non-sensical until properly initialized.\n\n  constructor(virtualLength: i32, initialPhysicalLength: i32) {\n    this.physicalLength = <i32>(\n      Math.max(initialPhysicalLength, MINIMUM_INITIAL_PACKED_ARRAY_CAPACITY)\n    );\n    this.isPacked =\n      this.physicalLength <= MAX_SUPPORTED_PACKED_COUNTS_ARRAY_LENGTH;\n    if (!this.isPacked) {\n      this.physicalLength = virtualLength;\n    }\n    this.array = new ArrayBuffer(this.physicalLength * 8);\n    this.initArrayViews(this.array);\n    this.init(virtualLength);\n  }\n\n  private initArrayViews(array: ArrayBuffer): void {\n    this.byteArray = Uint8Array.wrap(array);\n    this.shortArray = Uint16Array.wrap(array);\n    this.longArray = Uint64Array.wrap(array);\n  }\n\n  private init(virtualLength: i32): void {\n    if (!this.isPacked) {\n      // Deal with non-packed context init:\n      this.virtualLength = virtualLength;\n      return;\n    }\n\n    this.populatedShortLength = SET_0_START_INDEX + 8;\n\n    // Populate empty root entries, and point to them from the root indexes:\n    for (let i = 0; i < NUMBER_OF_SETS; i++) {\n      this.setAtShortIndex(SET_0_START_INDEX + i, 0);\n    }\n\n    this.setVirtualLength(virtualLength);\n  }\n\n  public clear(): void {\n    this.byteArray.fill(0);\n    this.init(this.virtualLength);\n  }\n\n  public copyAndIncreaseSize(\n    newPhysicalArrayLength: i32,\n    newVirtualArrayLength: i32\n  ): PackedArrayContext {\n    const ctx = new PackedArrayContext(\n      newVirtualArrayLength,\n      newPhysicalArrayLength\n    );\n    if (this.isPacked) {\n      ctx.populateEquivalentEntriesWithEntriesFromOther(this);\n    }\n    return ctx;\n  }\n\n  public getPopulatedShortLength(): i32 {\n    return this.populatedShortLength;\n  }\n\n  public getPopulatedLongLength(): i32 {\n    return (this.getPopulatedShortLength() + 3) >> 2; // round up\n  }\n\n  public setAtByteIndex(byteIndex: i32, value: u8): void {\n    this.byteArray[byteIndex] = value;\n  }\n\n  public getAtByteIndex(byteIndex: i32): u8 {\n    return this.byteArray[byteIndex];\n  }\n\n  /**\n   * add a byte value to a current byte value in the array\n   * @param byteIndex index of byte value to add to\n   * @param valueToAdd byte value to add\n   * @return the afterAddValue. ((afterAddValue & 0x100) != 0) indicates a carry.\n   */\n  public addAtByteIndex(byteIndex: i32, valueToAdd: u8): u8 {\n    const newValue = this.byteArray[byteIndex] + valueToAdd;\n    this.byteArray[byteIndex] = newValue;\n    return newValue;\n  }\n\n  setPopulatedLongLength(newPopulatedLongLength: i32): void {\n    this.populatedShortLength = newPopulatedLongLength << 2;\n  }\n\n  public getVirtualLength(): i32 {\n    return this.virtualLength;\n  }\n  public length(): i32 {\n    return this.physicalLength;\n  }\n\n  setAtShortIndex(shortIndex: i32, value: u16): void {\n    this.shortArray[shortIndex] = value;\n  }\n\n  setAtLongIndex(longIndex: i32, value: u64): void {\n    this.longArray[longIndex] = value;\n  }\n\n  getAtShortIndex(shortIndex: i32): u16 {\n    return this.shortArray[shortIndex];\n  }\n\n  getIndexAtShortIndex(shortIndex: i32): u16 {\n    return this.shortArray[shortIndex];\n  }\n\n  setPackedSlotIndicators(entryIndex: i32, newPackedSlotIndicators: u16): void {\n    this.setAtShortIndex(\n      entryIndex + NON_LEAF_ENTRY_SLOT_INDICATORS_OFFSET,\n      newPackedSlotIndicators\n    );\n  }\n\n  getPackedSlotIndicators(entryIndex: i32): u16 {\n    return (\n      this.shortArray[entryIndex + NON_LEAF_ENTRY_SLOT_INDICATORS_OFFSET] &\n      0xffff\n    );\n  }\n\n  private getIndexAtEntrySlot(entryIndex: i32, slot: i32): u16 {\n    return this.getAtShortIndex(\n      entryIndex + NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS + slot\n    );\n  }\n\n  setIndexAtEntrySlot(entryIndex: i32, slot: i32, newIndexValue: u16): void {\n    this.setAtShortIndex(\n      entryIndex + NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS + slot,\n      newIndexValue\n    );\n  }\n\n  private expandArrayIfNeeded(entryLengthInLongs: i32): void {\n    const currentLength = this.length();\n    if (currentLength < this.getPopulatedLongLength() + entryLengthInLongs) {\n      const growthIncrement = <i32>(\n        max(\n          max(entryLengthInLongs, PACKED_ARRAY_GROWTH_INCREMENT),\n          this.getPopulatedLongLength() >> PACKED_ARRAY_GROWTH_FRACTION_POW2\n        )\n      );\n      this.resizeArray(currentLength + growthIncrement);\n    }\n  }\n\n  private newEntry(entryLengthInShorts: i32): i32 {\n    // Add entry at the end of the array:\n\n    const newEntryIndex = this.populatedShortLength;\n    this.expandArrayIfNeeded((entryLengthInShorts >> 2) + 1);\n    this.populatedShortLength = newEntryIndex + entryLengthInShorts;\n\n    for (let i = 0; i < entryLengthInShorts; i++) {\n      this.setAtShortIndex(newEntryIndex + i, <u16>-1); // Poison value -1. Must be overriden before reads\n    }\n    return newEntryIndex;\n  }\n\n  private newLeafEntry(): i32 {\n    // Add entry at the end of the array:\n    let newEntryIndex = this.getPopulatedLongLength();\n    this.expandArrayIfNeeded(1);\n\n    this.setPopulatedLongLength(newEntryIndex + 1);\n\n    this.setAtLongIndex(newEntryIndex, 0);\n\n    return newEntryIndex;\n  }\n\n  /**\n   * Consolidate entry with previous entry version if one exists\n   *\n   * @param entryIndex The shortIndex of the entry to be consolidated\n   * @param previousVersionIndex the index of the previous version of the entry\n   */\n  private consolidateEntry(entryIndex: i32, previousVersionIndex: i32): void {\n    const previousVersionPackedSlotsIndicators = this.getPackedSlotIndicators(\n      previousVersionIndex\n    );\n    // Previous version exists, needs consolidation\n\n    const packedSlotsIndicators = this.getPackedSlotIndicators(entryIndex);\n\n    const insertedSlotMask =\n      packedSlotsIndicators ^ previousVersionPackedSlotsIndicators; // the only bit that differs\n    const slotsBelowBitNumber = packedSlotsIndicators & (insertedSlotMask - 1);\n    const insertedSlotIndex = bitCount(slotsBelowBitNumber);\n    const numberOfSlotsInEntry = bitCount(packedSlotsIndicators);\n\n    // Copy the entry slots from previous version, skipping the newly inserted slot in the target:\n    let sourceSlot = 0;\n    for (\n      let targetSlot: u8 = 0;\n      targetSlot < numberOfSlotsInEntry;\n      targetSlot++\n    ) {\n      if (targetSlot !== insertedSlotIndex) {\n        const indexAtSlot = this.getIndexAtEntrySlot(\n          previousVersionIndex,\n          sourceSlot\n        );\n        if (indexAtSlot !== 0) {\n          this.setIndexAtEntrySlot(entryIndex, targetSlot, indexAtSlot);\n        }\n        sourceSlot++;\n      }\n    }\n  }\n\n  /**\n   * Expand entry as indicated.\n   *\n   * @param existingEntryIndex the index of the entry\n   * @param entryPointerIndex  index to the slot pointing to the entry (needs to be fixed up)\n   * @param insertedSlotIndex  realtive [packed] index of slot being inserted into entry\n   * @param insertedSlotMask   mask value fo slot being inserted\n   * @param nextLevelIsLeaf    the level below this one is a leaf level\n   * @return the updated index of the entry (-1 if epansion failed due to conflict)\n   * @throws RetryException if expansion fails due to concurrent conflict, and caller should try again.\n   */\n  expandEntry(\n    existingEntryIndex: i32,\n    entryPointerIndex: i32,\n    insertedSlotIndex: i32,\n    insertedSlotMask: i32,\n    nextLevelIsLeaf: boolean\n  ): i32 {\n    let packedSlotIndicators =\n      (<i32>this.getAtShortIndex(existingEntryIndex)) & 0xffff;\n    packedSlotIndicators |= insertedSlotMask;\n    const numberOfslotsInExpandedEntry = bitCount(packedSlotIndicators);\n\n    if (insertedSlotIndex >= <i32>numberOfslotsInExpandedEntry) {\n      throw new Error(\n        \"inserted slot index is out of range given provided masks\"\n      );\n    }\n\n    const expandedEntryLength =\n      numberOfslotsInExpandedEntry + NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS;\n\n    // Create new next-level entry to refer to from slot at this level:\n    let indexOfNewNextLevelEntry = 0;\n    if (nextLevelIsLeaf) {\n      indexOfNewNextLevelEntry = this.newLeafEntry(); // Establish long-index to new leaf entry\n    } else {\n      // TODO: Optimize this by creating the whole sub-tree here, rather than a step that will immediaterly expand\n\n      // Create a new 1 word (empty, no slots set) entry for the next level:\n      indexOfNewNextLevelEntry = this.newEntry(\n        NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS\n      ); // Establish short-index to new leaf entry\n\n      this.setPackedSlotIndicators(indexOfNewNextLevelEntry, 0);\n    }\n\n    const insertedSlotValue = indexOfNewNextLevelEntry;\n\n    const expandedEntryIndex = this.newEntry(expandedEntryLength);\n\n    // populate the packed indicators word:\n    this.setPackedSlotIndicators(expandedEntryIndex, <u16>packedSlotIndicators);\n\n    // Populate the inserted slot with the index of the new next level entry:\n    this.setIndexAtEntrySlot(\n      expandedEntryIndex,\n      insertedSlotIndex,\n      <u16>insertedSlotValue\n    );\n\n    this.setAtShortIndex(entryPointerIndex, <u16>expandedEntryIndex);\n    this.consolidateEntry(expandedEntryIndex, existingEntryIndex);\n\n    return expandedEntryIndex;\n  }\n\n  //\n  //   ######   ######## ########    ##     ##    ###    ##             ## #### ##    ## ########  ######## ##     ##\n  //  ##    ##  ##          ##       ##     ##   ## ##   ##            ##   ##  ###   ## ##     ## ##        ##   ##\n  //  ##        ##          ##       ##     ##  ##   ##  ##           ##    ##  ####  ## ##     ## ##         ## ##\n  //  ##   #### ######      ##       ##     ## ##     ## ##          ##     ##  ## ## ## ##     ## ######      ###\n  //  ##    ##  ##          ##        ##   ##  ######### ##         ##      ##  ##  #### ##     ## ##         ## ##\n  //  ##    ##  ##          ##         ## ##   ##     ## ##        ##       ##  ##   ### ##     ## ##        ##   ##\n  //   ######   ########    ##          ###    ##     ## ######## ##       #### ##    ## ########  ######## ##     ##\n  //\n\n  getRootEntry(setNumber: i32, insertAsNeeded: boolean = false): i32 {\n    const entryPointerIndex = SET_0_START_INDEX + setNumber;\n    let entryIndex = <i32>this.getIndexAtShortIndex(entryPointerIndex);\n\n    if (entryIndex == 0) {\n      if (!insertAsNeeded) {\n        return 0; // Index does not currently exist in packed array;\n      }\n\n      entryIndex = this.newEntry(NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS);\n      // Create a new empty (no slots set) entry for the next level:\n      this.setPackedSlotIndicators(entryIndex, 0);\n\n      this.setAtShortIndex(entryPointerIndex, <u16>entryIndex);\n    }\n    return entryIndex;\n  }\n\n  /**\n   * Get the byte-index (into the packed array) corresponding to a given (set tree) value byte of given virtual index.\n   * Inserts new set tree nodes as needed if indicated.\n   *\n   * @param setNumber      The set tree number (0-7, 0 corresponding with the LSByte set tree)\n   * @param virtualIndex   The virtual index into the PackedArray\n   * @param insertAsNeeded If true, will insert new set tree nodes as needed if they do not already exist\n   * @return the byte-index corresponding to the given (set tree) value byte of the given virtual index\n   */\n  getPackedIndex(\n    setNumber: i32,\n    virtualIndex: i32,\n    insertAsNeeded: boolean\n  ): i32 {\n    if (virtualIndex >= this.virtualLength) {\n      throw new Error(\n        `Attempting access at index ${virtualIndex}, beyond virtualLength ${this.virtualLength}`\n      );\n    }\n\n    let entryPointerIndex = SET_0_START_INDEX + setNumber; // TODO init needed ?\n    let entryIndex = this.getRootEntry(setNumber, insertAsNeeded);\n    if (entryIndex == 0) {\n      return -1; // Index does not currently exist in packed array;\n    }\n\n    // Work down the levels of non-leaf entries:\n    for (\n      let indexShift = this.topLevelShift;\n      indexShift >= LEAF_LEVEL_SHIFT;\n      indexShift -= 4\n    ) {\n      const nextLevelIsLeaf = indexShift === LEAF_LEVEL_SHIFT;\n      // Target is a packedSlotIndicators entry\n      const packedSlotIndicators = this.getPackedSlotIndicators(entryIndex);\n      const slotBitNumber = (virtualIndex >>> indexShift) & 0xf;\n      const slotMask = 1 << slotBitNumber;\n      const slotsBelowBitNumber = packedSlotIndicators & (slotMask - 1);\n      const slotNumber = bitCount(slotsBelowBitNumber);\n\n      if ((packedSlotIndicators & slotMask) === 0) {\n        // The entryIndex slot does not have the contents we want\n        if (!insertAsNeeded) {\n          return -1; // Index does not currently exist in packed array;\n        }\n\n        // Expand the entry, adding the index to new entry at the proper slot:\n        entryIndex = this.expandEntry(\n          entryIndex,\n          entryPointerIndex,\n          slotNumber,\n          slotMask,\n          nextLevelIsLeaf\n        );\n      }\n\n      // Next level's entry pointer index is in the appropriate slot in in the entries array in this entry:\n      entryPointerIndex =\n        entryIndex + NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS + slotNumber;\n\n      entryIndex = this.getIndexAtShortIndex(entryPointerIndex);\n    }\n\n    // entryIndex is the long-index of a leaf entry that contains the value byte for the given set\n\n    const byteIndex = (entryIndex << 3) + (virtualIndex & 0x7); // Determine byte index offset within leaf entry\n    return byteIndex;\n  }\n\n  determineTopLevelShiftForVirtualLength(virtualLength: i32): i32 {\n    const sizeMagnitude = <i32>ceil(Math.log2(virtualLength));\n    const eightsSizeMagnitude = sizeMagnitude - 3;\n    let multipleOfFourSizeMagnitude =\n      <i32>ceil(<f64>eightsSizeMagnitude / 4.0) * 4;\n    multipleOfFourSizeMagnitude = max(multipleOfFourSizeMagnitude, 8);\n    const topLevelShiftNeeded = multipleOfFourSizeMagnitude - 4 + 3;\n    return topLevelShiftNeeded;\n  }\n\n  setVirtualLength(virtualLength: i32): void {\n    if (!this.isPacked) {\n      throw new Error(\n        \"Should never be adjusting the virtual size of a non-packed context\"\n      );\n    }\n    this.topLevelShift = this.determineTopLevelShiftForVirtualLength(\n      virtualLength\n    );\n    this.virtualLength = virtualLength;\n  }\n\n  getTopLevelShift(): i32 {\n    return this.topLevelShift;\n  }\n\n  //\n  //  ##     ##         ########   #######  ########  ##     ## ##          ###    ######## ########\n  //   ##   ##          ##     ## ##     ## ##     ## ##     ## ##         ## ##      ##    ##\n  //    ## ##           ##     ## ##     ## ##     ## ##     ## ##        ##   ##     ##    ##\n  //     ###    ####### ########  ##     ## ########  ##     ## ##       ##     ##    ##    ######\n  //    ## ##           ##        ##     ## ##        ##     ## ##       #########    ##    ##\n  //   ##   ##          ##        ##     ## ##        ##     ## ##       ##     ##    ##    ##\n  //  ##     ##         ##         #######  ##         #######  ######## ##     ##    ##    ########\n  //\n\n  public resizeArray(newLength: i32): void {\n    const tmp = new Uint8Array(newLength * 8);\n    tmp.set(this.byteArray);\n    this.array = tmp.buffer;\n    this.initArrayViews(this.array);\n    this.physicalLength = newLength;\n  }\n\n  private populateEquivalentEntriesWithEntriesFromOther(\n    other: PackedArrayContext\n  ): void {\n    if (this.virtualLength < other.getVirtualLength()) {\n      throw new Error(\"Cannot populate array of smaller virtual length\");\n    }\n\n    for (let i = 0; i < NUMBER_OF_SETS; i++) {\n      const otherEntryIndex = other.getAtShortIndex(SET_0_START_INDEX + i);\n      if (otherEntryIndex == 0) continue; // No tree to duplicate\n      let entryIndexPointer = SET_0_START_INDEX + i;\n      for (let i = this.topLevelShift; i > other.topLevelShift; i -= 4) {\n        // for each inserted level:\n        // Allocate entry in other:\n        const sizeOfEntry = NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS + 1;\n        const newEntryIndex = this.newEntry(sizeOfEntry);\n\n        // Link new level in.\n        this.setAtShortIndex(entryIndexPointer, <u16>newEntryIndex);\n        // Populate new level entry, use pointer to slot 0 as place to populate under:\n        this.setPackedSlotIndicators(newEntryIndex, 0x1); // Slot 0 populated\n        entryIndexPointer =\n          newEntryIndex + NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS; // Where the slot 0 index goes.\n      }\n      this.copyEntriesAtLevelFromOther(\n        other,\n        otherEntryIndex,\n        entryIndexPointer,\n        other.topLevelShift\n      );\n    }\n  }\n\n  private copyEntriesAtLevelFromOther(\n    other: PackedArrayContext,\n    otherLevelEntryIndex: i32,\n    levelEntryIndexPointer: i32,\n    otherIndexShift: i32\n  ): void {\n    const nextLevelIsLeaf = otherIndexShift == LEAF_LEVEL_SHIFT;\n    const packedSlotIndicators = other.getPackedSlotIndicators(\n      otherLevelEntryIndex\n    );\n    const numberOfSlots = bitCount(packedSlotIndicators);\n    const sizeOfEntry = NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS + numberOfSlots;\n    const entryIndex = this.newEntry(sizeOfEntry);\n\n    this.setAtShortIndex(levelEntryIndexPointer, <u16>entryIndex);\n    this.setAtShortIndex(\n      entryIndex + NON_LEAF_ENTRY_SLOT_INDICATORS_OFFSET,\n      packedSlotIndicators\n    );\n\n    for (let i: u8 = 0; i < numberOfSlots; i++) {\n      if (nextLevelIsLeaf) {\n        // Make leaf in other:\n        const leafEntryIndex = this.newLeafEntry();\n\n        this.setIndexAtEntrySlot(entryIndex, i, <u16>leafEntryIndex);\n\n        // OPTIM\n        // avoid iteration on all the values of the source ctx\n        const otherNextLevelEntryIndex = other.getIndexAtEntrySlot(\n          otherLevelEntryIndex,\n          i\n        );\n        this.longArray[leafEntryIndex] =\n          other.longArray[otherNextLevelEntryIndex];\n      } else {\n        const otherNextLevelEntryIndex = other.getIndexAtEntrySlot(\n          otherLevelEntryIndex,\n          i\n        );\n        this.copyEntriesAtLevelFromOther(\n          other,\n          otherNextLevelEntryIndex,\n          entryIndex + NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS + i,\n          otherIndexShift - 4\n        );\n      }\n    }\n  }\n\n  getAtUnpackedIndex(index: i32): u64 {\n    return this.longArray[index];\n  }\n\n  setAtUnpackedIndex(index: i32, newValue: u64): void {\n    this.longArray[index] = newValue;\n  }\n\n  lazysetAtUnpackedIndex(index: i32, newValue: u64): void {\n    this.longArray[index] = newValue;\n  }\n\n  incrementAndGetAtUnpackedIndex(index: i32): u64 {\n    this.longArray[index]++;\n    return this.longArray[index];\n  }\n\n  addAndGetAtUnpackedIndex(index: i32, valueToAdd: u64): u64 {\n    this.longArray[index] += valueToAdd;\n    return this.longArray[index];\n  }\n\n  //\n  //   ########  #######           ######  ######## ########  #### ##    ##  ######\n  //      ##    ##     ##         ##    ##    ##    ##     ##  ##  ###   ## ##    ##\n  //      ##    ##     ##         ##          ##    ##     ##  ##  ####  ## ##\n  //      ##    ##     ## #######  ######     ##    ########   ##  ## ## ## ##   ####\n  //      ##    ##     ##               ##    ##    ##   ##    ##  ##  #### ##    ##\n  //      ##    ##     ##         ##    ##    ##    ##    ##   ##  ##   ### ##    ##\n  //      ##     #######           ######     ##    ##     ## #### ##    ##  ######\n  //\n\n  private nonLeafEntryToString(\n    entryIndex: i32,\n    indexShift: i32,\n    indentLevel: i32\n  ): string {\n    let output = \"\";\n    for (let i = 0; i < indentLevel; i++) {\n      output += \"  \";\n    }\n    const packedSlotIndicators = this.getPackedSlotIndicators(entryIndex);\n    output +=\n      \"slotIndiators: 0x\" +\n      toHex(packedSlotIndicators) +\n      \", prevVersionIndex: 0: [ \";\n\n    const numberOfslotsInEntry = bitCount(packedSlotIndicators);\n    for (let i: u8 = 0; i < numberOfslotsInEntry; i++) {\n      output += this.getIndexAtEntrySlot(entryIndex, i).toString();\n      if (i < numberOfslotsInEntry - 1) {\n        output += \", \";\n      }\n    }\n    output += \" ] (indexShift = \" + indexShift.toString() + \")\\n\";\n    const nextLevelIsLeaf = indexShift == LEAF_LEVEL_SHIFT;\n    for (let i: u8 = 0; i < numberOfslotsInEntry; i++) {\n      const nextLevelEntryIndex = this.getIndexAtEntrySlot(entryIndex, i);\n      if (nextLevelIsLeaf) {\n        output += this.leafEntryToString(nextLevelEntryIndex, indentLevel + 4);\n      } else {\n        output += this.nonLeafEntryToString(\n          nextLevelEntryIndex,\n          indexShift - 4,\n          indentLevel + 4\n        );\n      }\n    }\n\n    return output;\n  }\n\n  private leafEntryToString(entryIndex: i32, indentLevel: i32): string {\n    let output = \"\";\n    for (let i = 0; i < indentLevel; i++) {\n      output += \"  \";\n    }\n\n    output += \"Leaf bytes : \";\n    for (let i = 0; i < 8; i++) {\n      output += \"0x\" + toHex(this.byteArray[entryIndex * 8 + i]) + \" \";\n    }\n    output += \"\\n\";\n\n    return output;\n  }\n\n  public toString(): string {\n    let output = \"PackedArrayContext:\\n\";\n    if (!this.isPacked) {\n      return output + \"Context is unpacked:\\n\"; // unpackedToString();\n    }\n    for (let setNumber = 0; setNumber < NUMBER_OF_SETS; setNumber++) {\n      const entryPointerIndex = SET_0_START_INDEX + setNumber;\n      const entryIndex = this.getIndexAtShortIndex(entryPointerIndex);\n      output +=\n        \"Set \" +\n        setNumber.toString() +\n        \": root = \" +\n        entryIndex.toString() +\n        \" \\n\";\n      if (entryIndex == 0) continue;\n      output += this.nonLeafEntryToString(entryIndex, this.topLevelShift, 4);\n    }\n    //output += recordedValuesToString();\n    return output;\n  }\n}\n\nconst hexaCode = [\n  \"0\",\n  \"1\",\n  \"2\",\n  \"3\",\n  \"4\",\n  \"5\",\n  \"6\",\n  \"7\",\n  \"8\",\n  \"9\",\n  \"a\",\n  \"b\",\n  \"c\",\n  \"d\",\n  \"e\",\n  \"f\",\n];\n\nexport function toHex(n: u64): string {\n  let i = n;\n  let result = \"\";\n  do {\n    const current = <i32>(i & 0xf);\n    result = hexaCode[current] + result;\n    i = i >> 4;\n  } while (i > 0);\n\n  return result.padStart(2, \"0\");\n}\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport {\n  PackedArrayContext,\n  MINIMUM_INITIAL_PACKED_ARRAY_CAPACITY,\n} from \"./PackedArrayContext\";\n\nconst NUMBER_OF_SETS: u8 = 8;\n\n/**\n * A Packed array of signed 64 bit values, and supports {@link #get get()}, {@link #set set()},\n * {@link #add add()} and {@link #increment increment()} operations on the logical contents of the array.\n *\n * An {@link PackedLongArray} Uses {@link PackedArrayContext} to track\n * the array's logical contents. Contexts may be switched when a context requires resizing\n * to complete logical array operations (get, set, add, increment). Contexts are\n * established and used within critical sections in order to facilitate concurrent\n * implementors.\n *\n */\nexport class PackedArray {\n  [key: number]: number;\n\n  private arrayContext: PackedArrayContext;\n\n  constructor(\n    virtualLength: i32,\n    initialPhysicalLength: i32 = MINIMUM_INITIAL_PACKED_ARRAY_CAPACITY\n  ) {\n    this.arrayContext = new PackedArrayContext(\n      virtualLength,\n      initialPhysicalLength\n    );\n  }\n\n  public resize(newVirtualArrayLength: i32): PackedArray {\n    this.setVirtualLength(newVirtualArrayLength);\n    return this;\n  }\n\n  public setVirtualLength(newVirtualArrayLength: i32): void {\n    if (newVirtualArrayLength < this.length()) {\n      throw new Error(\n        \"Cannot set virtual length, as requested length \" +\n          newVirtualArrayLength.toString() +\n          \" is smaller than the current virtual length \" +\n          this.length().toString()\n      );\n    }\n    const currentArrayContext = this.arrayContext;\n    if (\n      currentArrayContext.isPacked &&\n      currentArrayContext.determineTopLevelShiftForVirtualLength(\n        newVirtualArrayLength\n      ) == currentArrayContext.getTopLevelShift()\n    ) {\n      // No changes to the array context contents is needed. Just change the virtual length.\n      currentArrayContext.setVirtualLength(newVirtualArrayLength);\n      return;\n    }\n    this.arrayContext = currentArrayContext.copyAndIncreaseSize(\n      this.getPhysicalLength(),\n      newVirtualArrayLength\n    );\n  }\n\n  @operator(\"[]\") private __get(index: i32): u64 {\n    return this.get(index);\n  }\n\n  @operator(\"[]=\") private __set(index: i32, value: u64): void {\n    this.set(index, value);\n  }\n\n  /**\n   * Get value at virtual index in the array\n   * @param index the virtual array index\n   * @return the array value at the virtual index given\n   */\n  get(index: i32): u64 {\n    let value: u64 = 0;\n    for (let byteNum: u8 = 0; byteNum < NUMBER_OF_SETS; byteNum++) {\n      let byteValueAtPackedIndex: u64 = 0;\n\n      // Deal with unpacked context:\n      if (!this.arrayContext.isPacked) {\n        return this.arrayContext.getAtUnpackedIndex(index);\n      }\n      // Context is packed:\n      const packedIndex = this.arrayContext.getPackedIndex(\n        byteNum,\n        index,\n        false\n      );\n      if (packedIndex < 0) {\n        return value;\n      }\n      byteValueAtPackedIndex =\n        (<u64>this.arrayContext.getAtByteIndex(packedIndex)) << (byteNum << 3);\n      value += byteValueAtPackedIndex;\n    }\n    return value;\n  }\n\n  /**\n   * Increment value at a virrual index in the array\n   * @param index virtual index of value to increment\n   */\n  public increment(index: i32): void {\n    this.add(index, 1);\n  }\n\n  private safeGetPackedIndexgetPackedIndex(\n    setNumber: i32,\n    virtualIndex: i32\n  ): i32 {\n    return this.arrayContext.getPackedIndex(setNumber, virtualIndex, true);\n  }\n\n  /**\n   * Add to a value at a virtual index in the array\n   * @param index the virtual index of the value to be added to\n   * @param value the value to add\n   */\n  public add(index: i32, value: u64): void {\n    let remainingValueToAdd = value;\n\n    for (\n      let byteNum = 0, byteShift = 0;\n      byteNum < NUMBER_OF_SETS;\n      byteNum++, byteShift += 8\n    ) {\n      // Deal with unpacked context:\n      if (!this.arrayContext.isPacked) {\n        this.arrayContext.addAndGetAtUnpackedIndex(index, value);\n        return;\n      }\n      // Context is packed:\n      const packedIndex = this.safeGetPackedIndexgetPackedIndex(byteNum, index);\n\n      const byteToAdd = remainingValueToAdd & 0xff;\n\n      const afterAddByteValue = this.arrayContext.addAtByteIndex(\n        packedIndex,\n        byteToAdd\n      );\n\n      // Reduce remaining value to add by amount just added:\n      remainingValueToAdd -= byteToAdd;\n\n      remainingValueToAdd = remainingValueToAdd >> 8;\n      // Account for carry:\n      remainingValueToAdd += afterAddByteValue >> 8;\n\n      if (remainingValueToAdd == 0) {\n        return; // nothing to add to higher magnitudes\n      }\n    }\n  }\n\n  /**\n   * Set the value at a virtual index in the array\n   * @param index the virtual index of the value to set\n   * @param value the value to set\n   */\n  set(index: i32, value: u64): void {\n    let bytesAlreadySet: u8 = 0;\n    let valueForNextLevels = value;\n    for (let byteNum: u8 = 0; byteNum < NUMBER_OF_SETS; byteNum++) {\n      // Establish context within: critical section\n\n      // Deal with unpacked context:\n      if (!this.arrayContext.isPacked) {\n        this.arrayContext.setAtUnpackedIndex(index, value);\n        return;\n      }\n      // Context is packed:\n      if (valueForNextLevels == 0) {\n        // Special-case zeros to avoid inflating packed array for no reason\n        const packedIndex = this.arrayContext.getPackedIndex(\n          byteNum,\n          index,\n          false\n        );\n        if (packedIndex < 0) {\n          return; // no need to create entries for zero values if they don't already exist\n        }\n      }\n      // Make sure byte is populated:\n      const packedIndex = this.arrayContext.getPackedIndex(\n        byteNum,\n        index,\n        true\n      );\n\n      // Determine value to write, and prepare for next levels\n      const byteToWrite: u8 = <u8>(valueForNextLevels & 0xff);\n      valueForNextLevels = valueForNextLevels >> 8;\n\n      if (byteNum < bytesAlreadySet) {\n        // We want to avoid writing to the same byte twice when not doing so for the\n        // entire 64 bit value atomically, as doing so opens a race with e.g. concurrent\n        // adders. So dobn't actually write the byte if has been written before.\n        continue;\n      }\n      this.arrayContext.setAtByteIndex(packedIndex, byteToWrite);\n      bytesAlreadySet++;\n    }\n  }\n\n  /**\n   * Get the current physical length (in longs) of the array's backing storage\n   * @return the current physical length (in longs) of the array's current backing storage\n   */\n  getPhysicalLength(): i32 {\n    return this.arrayContext.physicalLength;\n  }\n\n  public get estimatedFootprintInBytes(): i32 {\n    // @ts-ignore\n    return offsetof<PackedArray>() + this.getPhysicalLength();\n  }\n\n  /**\n   * Get the (virtual) length of the array\n   * @return the (virtual) length of the array\n   */\n  length(): i32 {\n    return this.arrayContext.getVirtualLength();\n  }\n\n  /**\n   * Clear the array contents\n   */\n  public clear(): void {\n    this.arrayContext.clear();\n  }\n\n  public toString(): string {\n    let output = \"PackedArray:\\n\";\n    output += this.arrayContext.toString();\n    return output;\n  }\n}\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport Histogram from \"./Histogram\";\nimport {\n  Uint8Storage,\n  Uint16Storage,\n  Uint32Storage,\n  Uint64Storage,\n} from \"./Histogram\";\nimport { decodeFromByteBuffer } from \"./encoding\";\nimport ByteBuffer from \"./ByteBuffer\";\nimport { PackedArray } from \"./packedarray/PackedArray\";\n\nexport const UINT8ARRAY_ID = idof<Uint8Array>();\n\nclass HistogramAdapter<T, U> {\n  private _histogram: Histogram<T, U>;\n  constructor(\n    lowestDiscernibleValue: f64,\n    highestTrackableValue: f64,\n    numberOfSignificantValueDigits: f64,\n    autoResize: boolean,\n    histogram: Histogram<T, U> | null = null\n  ) {\n    if (histogram) {\n      this._histogram = histogram;\n    } else {\n      this._histogram = new Histogram<T, U>(\n        <u64>lowestDiscernibleValue,\n        <u64>highestTrackableValue,\n        <u8>numberOfSignificantValueDigits\n      );\n      this._histogram.autoResize = autoResize;\n    }\n  }\n\n  public get autoResize(): boolean {\n    return this._histogram.autoResize;\n  }\n\n  public set autoResize(resize: boolean) {\n    this._histogram.autoResize = resize;\n  }\n\n  public get highestTrackableValue(): f64 {\n    return <f64>this._histogram.highestTrackableValue;\n  }\n\n  public set highestTrackableValue(value: f64) {\n    this._histogram.highestTrackableValue = <u64>value;\n  }\n\n  public get startTimeStampMsec(): f64 {\n    return <f64>this._histogram.startTimeStampMsec;\n  }\n\n  public set startTimeStampMsec(value: f64) {\n    this._histogram.startTimeStampMsec = <u64>value;\n  }\n\n  public get endTimeStampMsec(): f64 {\n    return <f64>this._histogram.endTimeStampMsec;\n  }\n\n  public set endTimeStampMsec(value: f64) {\n    this._histogram.endTimeStampMsec = <u64>value;\n  }\n\n  public get minNonZeroValue(): f64 {\n    return <f64>this._histogram.minNonZeroValue;\n  }\n\n  public get maxValue(): f64 {\n    return <f64>this._histogram.maxValue;\n  }\n\n  public get totalCount(): f64 {\n    return <f64>this._histogram.totalCount;\n  }\n\n  public get stdDeviation(): f64 {\n    return <f64>this._histogram.getStdDeviation();\n  }\n\n  public get mean(): f64 {\n    return <f64>this._histogram.getMean();\n  }\n\n  public get estimatedFootprintInBytes(): f64 {\n    return <f64>(\n      (offsetof<HistogramAdapter<T, U>>() +\n        this._histogram.estimatedFootprintInBytes)\n    );\n  }\n\n  recordValue(value: f64): void {\n    this._histogram.recordSingleValue(<u64>value);\n  }\n\n  recordValueWithCount(value: f64, count: f64): void {\n    this._histogram.recordCountAtValue(<u64>count, <u64>value);\n  }\n\n  recordValueWithExpectedInterval(\n    value: f64,\n    expectedIntervalBetweenValueSamples: f64\n  ): void {\n    this._histogram.recordSingleValueWithExpectedInterval(\n      <u64>value,\n      <u64>expectedIntervalBetweenValueSamples\n    );\n  }\n\n  getValueAtPercentile(percentile: f64): f64 {\n    return <f64>this._histogram.getValueAtPercentile(percentile);\n  }\n\n  outputPercentileDistribution(\n    percentileTicksPerHalfDistance: f64,\n    outputValueUnitScalingRatio: f64\n  ): string {\n    return this._histogram.outputPercentileDistribution(\n      <i32>percentileTicksPerHalfDistance,\n      outputValueUnitScalingRatio\n    );\n  }\n\n  copyCorrectedForCoordinatedOmission(\n    expectedIntervalBetweenValueSamples: f64\n  ): HistogramAdapter<T, U> {\n    const copy = this._histogram.copyCorrectedForCoordinatedOmission(\n      <u64>expectedIntervalBetweenValueSamples\n    );\n\n    return new HistogramAdapter<T, U>(0, 0, 0, false, copy);\n  }\n\n  addHistogram8(otherHistogram: Histogram8): void {\n    this._histogram.add(otherHistogram._histogram);\n  }\n  addHistogram16(otherHistogram: Histogram16): void {\n    this._histogram.add(otherHistogram._histogram);\n  }\n  addHistogram32(otherHistogram: Histogram32): void {\n    this._histogram.add(otherHistogram._histogram);\n  }\n  addHistogram64(otherHistogram: Histogram64): void {\n    this._histogram.add(otherHistogram._histogram);\n  }\n  addPackedHistogram(otherHistogram: PackedHistogram): void {\n    this._histogram.add(otherHistogram._histogram);\n  }\n\n  subtractHistogram8(otherHistogram: Histogram8): void {\n    this._histogram.subtract(otherHistogram._histogram);\n  }\n  subtractHistogram16(otherHistogram: Histogram16): void {\n    this._histogram.subtract(otherHistogram._histogram);\n  }\n  subtractHistogram32(otherHistogram: Histogram32): void {\n    this._histogram.subtract(otherHistogram._histogram);\n  }\n  subtractHistogram64(otherHistogram: Histogram64): void {\n    this._histogram.subtract(otherHistogram._histogram);\n  }\n  subtractPackedHistogram(otherHistogram: PackedHistogram): void {\n    this._histogram.subtract(otherHistogram._histogram);\n  }\n\n  encode(): Uint8Array {\n    return this._histogram.encode();\n  }\n\n  reset(): void {\n    this._histogram.reset();\n  }\n}\n\nexport class Histogram8 extends HistogramAdapter<Uint8Storage, u8> {}\nexport class Histogram16 extends HistogramAdapter<Uint16Storage, u16> {}\nexport class Histogram32 extends HistogramAdapter<Uint32Storage, u32> {}\nexport class Histogram64 extends HistogramAdapter<Uint64Storage, u64> {}\nexport class PackedHistogram extends HistogramAdapter<PackedArray, u64> {}\n\nfunction decodeHistogram<T, U>(\n  data: Uint8Array,\n  minBarForHighestTrackableValue: f64\n): HistogramAdapter<T, U> {\n  const buffer = new ByteBuffer(data);\n  const histogram = decodeFromByteBuffer<T, U>(\n    buffer,\n    <u64>minBarForHighestTrackableValue\n  );\n  return new HistogramAdapter<T, U>(0, 0, 0, false, histogram);\n}\n\nexport function decodeHistogram8(\n  data: Uint8Array,\n  minBarForHighestTrackableValue: f64\n): HistogramAdapter<Uint8Storage, u8> {\n  return decodeHistogram<Uint8Storage, u8>(\n    data,\n    minBarForHighestTrackableValue\n  );\n}\nexport function decodeHistogram16(\n  data: Uint8Array,\n  minBarForHighestTrackableValue: f64\n): HistogramAdapter<Uint16Storage, u16> {\n  return decodeHistogram<Uint16Storage, u16>(\n    data,\n    minBarForHighestTrackableValue\n  );\n}\nexport function decodeHistogram32(\n  data: Uint8Array,\n  minBarForHighestTrackableValue: f64\n): HistogramAdapter<Uint32Storage, u32> {\n  return decodeHistogram<Uint32Storage, u32>(\n    data,\n    minBarForHighestTrackableValue\n  );\n}\nexport function decodeHistogram64(\n  data: Uint8Array,\n  minBarForHighestTrackableValue: f64\n): HistogramAdapter<Uint64Storage, u64> {\n  return decodeHistogram<Uint64Storage, u64>(\n    data,\n    minBarForHighestTrackableValue\n  );\n}\nexport function decodePackedHistogram(\n  data: Uint8Array,\n  minBarForHighestTrackableValue: f64\n): HistogramAdapter<PackedArray, u64> {\n  return decodeHistogram<PackedArray, u64>(\n    data,\n    minBarForHighestTrackableValue\n  );\n}\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport { AbstractHistogramBase } from \"./AbstractHistogramBase\";\nimport RecordedValuesIterator from \"./RecordedValuesIterator\";\nimport PercentileIterator from \"./PercentileIterator\";\n\nimport ulp from \"./ulp\";\nimport { FloatFormatter, IntegerFormatter } from \"./formatters\";\nimport ByteBuffer from \"./ByteBuffer\";\nimport { encodeIntoByteBuffer } from \"./encoding\";\nimport { PackedArray } from \"./packedarray/PackedArray\";\n\nexport default class Histogram<T, U> extends AbstractHistogramBase<T, U> {\n  // \"Hot\" accessed fields (used in the the value recording code path) are bunched here, such\n  // that they will have a good chance of ending up in the same cache line as the totalCounts and\n  // counts array reference fields that subclass implementations will typically add.\n\n  /**\n   * Number of leading zeros in the largest value that can fit in bucket 0.\n   */\n  leadingZeroCountBase: i32;\n  subBucketHalfCountMagnitude: i32;\n  /**\n   * Largest k such that 2^k &lt;= lowestDiscernibleValue\n   */\n  unitMagnitude: i32;\n  subBucketHalfCount: i32;\n\n  lowestDiscernibleValueRounded: u64;\n\n  /**\n   * Biggest value that can fit in bucket 0\n   */\n  subBucketMask: u64;\n  /**\n   * Lowest unitMagnitude bits are set\n   */\n  unitMagnitudeMask: u64;\n\n  maxValue: u64 = 0;\n  minNonZeroValue: u64 = U64.MAX_VALUE;\n\n  counts: T;\n  totalCount: u64 = 0;\n\n  constructor(\n    lowestDiscernibleValue: u64,\n    highestTrackableValue: u64,\n    numberOfSignificantValueDigits: u8\n  ) {\n    super();\n\n    // Verify argument validity\n    if (lowestDiscernibleValue < 1) {\n      throw new Error(\"lowestDiscernibleValue must be >= 1\");\n    }\n    if (highestTrackableValue < 2 * lowestDiscernibleValue) {\n      throw new Error(\n        `highestTrackableValue must be >= 2 * lowestDiscernibleValue ( 2 * ${lowestDiscernibleValue} )`\n      );\n    }\n    if (\n      numberOfSignificantValueDigits < 0 ||\n      numberOfSignificantValueDigits > 5\n    ) {\n      throw new Error(\"numberOfSignificantValueDigits must be between 0 and 5\");\n    }\n    this.identity = AbstractHistogramBase.identityBuilder++;\n\n    this.init(\n      lowestDiscernibleValue,\n      highestTrackableValue,\n      numberOfSignificantValueDigits,\n      1.0\n    );\n  }\n\n  init(\n    lowestDiscernibleValue: u64,\n    highestTrackableValue: u64,\n    numberOfSignificantValueDigits: u8,\n    integerToDoubleValueConversionRatio: f64\n  ): void {\n    this.lowestDiscernibleValue = lowestDiscernibleValue;\n    this.highestTrackableValue = highestTrackableValue;\n    this.numberOfSignificantValueDigits = numberOfSignificantValueDigits;\n    this.integerToDoubleValueConversionRatio = integerToDoubleValueConversionRatio;\n\n    /*\n     * Given a 3 decimal point accuracy, the expectation is obviously for \"+/- 1 unit at 1000\". It also means that\n     * it's \"ok to be +/- 2 units at 2000\". The \"tricky\" thing is that it is NOT ok to be +/- 2 units at 1999. Only\n     * starting at 2000. So internally, we need to maintain single unit resolution to 2x 10^decimalPoints.\n     */\n    const largestValueWithSingleUnitResolution =\n      2 * <u64>Math.pow(10, numberOfSignificantValueDigits);\n\n    this.unitMagnitude = <i32>floor(Math.log2(<f64>lowestDiscernibleValue));\n\n    //this.lowestDiscernibleValueRounded = pow(2, this.unitMagnitude);\n    this.unitMagnitudeMask = (1 << this.unitMagnitude) - 1;\n\n    // We need to maintain power-of-two subBucketCount (for clean direct indexing) that is large enough to\n    // provide unit resolution to at least largestValueWithSingleUnitResolution. So figure out\n    // largestValueWithSingleUnitResolution's nearest power-of-two (rounded up), and use that:\n    const subBucketCountMagnitude = <i32>(\n      ceil(Math.log2(<f64>largestValueWithSingleUnitResolution))\n    );\n    this.subBucketHalfCountMagnitude = subBucketCountMagnitude - 1;\n    this.subBucketCount = 1 << subBucketCountMagnitude;\n    this.subBucketHalfCount = this.subBucketCount >> 1;\n    this.subBucketMask = (<u64>this.subBucketCount - 1) << this.unitMagnitude;\n\n    this.establishSize(highestTrackableValue);\n    // @ts-ignore\n    this.counts = instantiate<T>(this.countsArrayLength);\n\n    this.leadingZeroCountBase =\n      64 - this.unitMagnitude - this.subBucketHalfCountMagnitude - 1;\n    this.percentileIterator = new PercentileIterator(this, 1);\n    this.recordedValuesIterator = new RecordedValuesIterator(this);\n  }\n\n  /**\n   * The buckets (each of which has subBucketCount sub-buckets, here assumed to be 2048 as an example) overlap:\n   *\n   * <pre>\n   * The 0'th bucket covers from 0...2047 in multiples of 1, using all 2048 sub-buckets\n   * The 1'th bucket covers from 2048..4097 in multiples of 2, using only the top 1024 sub-buckets\n   * The 2'th bucket covers from 4096..8191 in multiple of 4, using only the top 1024 sub-buckets\n   * ...\n   * </pre>\n   *\n   * Bucket 0 is \"special\" here. It is the only one that has 2048 entries. All the rest have 1024 entries (because\n   * their bottom half overlaps with and is already covered by the all of the previous buckets put together). In other\n   * words, the k'th bucket could represent 0 * 2^k to 2048 * 2^k in 2048 buckets with 2^k precision, but the midpoint\n   * of 1024 * 2^k = 2048 * 2^(k-1) = the k-1'th bucket's end, so we would use the previous bucket for those lower\n   * values as it has better precision.\n   */\n  establishSize(newHighestTrackableValue: u64): void {\n    // establish counts array length:\n    this.countsArrayLength = this.determineArrayLengthNeeded(\n      newHighestTrackableValue\n    );\n    // establish exponent range needed to support the trackable value with no overflow:\n    this.bucketCount = this.getBucketsNeededToCoverValue(\n      newHighestTrackableValue\n    );\n    // establish the new highest trackable value:\n    this.highestTrackableValue = newHighestTrackableValue;\n  }\n\n  determineArrayLengthNeeded(highestTrackableValue: u64): i32 {\n    if (highestTrackableValue < 2 * this.lowestDiscernibleValue) {\n      throw new Error(\n        \"highestTrackableValue cannot be < (2 * lowestDiscernibleValue)\"\n      );\n    }\n    //determine counts array length needed:\n    const countsArrayLength = this.getLengthForNumberOfBuckets(\n      this.getBucketsNeededToCoverValue(highestTrackableValue)\n    );\n    return countsArrayLength;\n  }\n\n  /**\n   * If we have N such that subBucketCount * 2^N > max value, we need storage for N+1 buckets, each with enough\n   * slots to hold the top half of the subBucketCount (the lower half is covered by previous buckets), and the +1\n   * being used for the lower half of the 0'th bucket. Or, equivalently, we need 1 more bucket to capture the max\n   * value if we consider the sub-bucket length to be halved.\n   */\n  getLengthForNumberOfBuckets(numberOfBuckets: i32): i32 {\n    const lengthNeeded: i32 =\n      (numberOfBuckets + 1) * (this.subBucketCount >> 1);\n    return lengthNeeded;\n  }\n\n  getBucketsNeededToCoverValue(value: u64): i32 {\n    // the k'th bucket can express from 0 * 2^k to subBucketCount * 2^k in units of 2^k\n    let smallestUntrackableValue =\n      (<u64>this.subBucketCount) << this.unitMagnitude;\n    // always have at least 1 bucket\n    let bucketsNeeded = 1;\n    while (smallestUntrackableValue <= value) {\n      if (smallestUntrackableValue > u64.MAX_VALUE >> 1) {\n        // next shift will overflow, meaning that bucket could represent values up to ones greater than\n        // Number.MAX_SAFE_INTEGER, so it's the last bucket\n        return bucketsNeeded + 1;\n      }\n      smallestUntrackableValue = smallestUntrackableValue << 1;\n      bucketsNeeded++;\n    }\n    return bucketsNeeded;\n  }\n\n  /**\n   * Record a value in the histogram\n   *\n   * @param value The value to be recorded\n   * @throws may throw Error if value is exceeds highestTrackableValue\n   */\n  recordValue(value: u64): void {\n    this.recordSingleValue(value);\n  }\n\n  recordSingleValue(value: u64): void {\n    const countsIndex = this.countsArrayIndex(value);\n    if (countsIndex >= this.countsArrayLength) {\n      // @ts-ignore\n      this.handleRecordException(<U>1, value);\n    } else {\n      this.incrementCountAtIndex(countsIndex);\n    }\n    this.updateMinAndMax(value);\n    this.incrementTotalCount();\n  }\n\n  handleRecordException(count: u64, value: u64): void {\n    if (!this.autoResize) {\n      throw new Error(\n        \"Value \" + value.toString() + \" is outside of histogram covered range\"\n      );\n    }\n    this.resize(value);\n    const countsIndex: i32 = this.countsArrayIndex(value);\n    this.addToCountAtIndex(countsIndex, count);\n    this.highestTrackableValue = this.highestEquivalentValue(\n      this.valueFromIndex(this.countsArrayLength - 1)\n    );\n  }\n\n  countsArrayIndex(value: u64): i32 {\n    if (value < 0) {\n      throw new Error(\"Histogram recorded value cannot be negative.\");\n    }\n    const bucketIndex = this.getBucketIndex(value);\n    const subBucketIndex = this.getSubBucketIndex(value, bucketIndex);\n    return this.computeCountsArrayIndex(bucketIndex, subBucketIndex);\n  }\n\n  private computeCountsArrayIndex(bucketIndex: i32, subBucketIndex: i32): i32 {\n    assert(subBucketIndex < this.subBucketCount);\n    assert(bucketIndex == 0 || subBucketIndex >= this.subBucketHalfCount);\n\n    // Calculate the index for the first entry that will be used in the bucket (halfway through subBucketCount).\n    // For bucketIndex 0, all subBucketCount entries may be used, but bucketBaseIndex is still set in the middle.\n    const bucketBaseIndex =\n      (bucketIndex + 1) * (1 << this.subBucketHalfCountMagnitude);\n    // Calculate the offset in the bucket. This subtraction will result in a positive value in all buckets except\n    // the 0th bucket (since a value in that bucket may be less than half the bucket's 0 to subBucketCount range).\n    // However, this works out since we give bucket 0 twice as much space.\n    const offsetInBucket = subBucketIndex - this.subBucketHalfCount;\n    // The following is the equivalent of ((subBucketIndex  - subBucketHalfCount) + bucketBaseIndex;\n    return bucketBaseIndex + offsetInBucket;\n  }\n\n  /**\n   * @return the lowest (and therefore highest precision) bucket index that can represent the value\n   */\n  getBucketIndex(value: u64): i32 {\n    // Calculates the number of powers of two by which the value is greater than the biggest value that fits in\n    // bucket 0. This is the bucket index since each successive bucket can hold a value 2x greater.\n    // The mask maps small values to bucket 0.\n    // return this.leadingZeroCountBase - Long.numberOfLeadingZeros(value | subBucketMask);\n\n    return this.leadingZeroCountBase - <i32>clz(value | this.subBucketMask);\n    /*return <i32>(\n      max(\n        floor(Math.log2(<f64>value)) -\n          this.subBucketHalfCountMagnitude -\n          this.unitMagnitude,\n        0\n      )\n    );*/\n  }\n\n  getSubBucketIndex(value: u64, bucketIndex: i32): i32 {\n    // For bucketIndex 0, this is just value, so it may be anywhere in 0 to subBucketCount.\n    // For other bucketIndex, this will always end up in the top half of subBucketCount: assume that for some bucket\n    // k > 0, this calculation will yield a value in the bottom half of 0 to subBucketCount. Then, because of how\n    // buckets overlap, it would have also been in the top half of bucket k-1, and therefore would have\n    // returned k-1 in getBucketIndex(). Since we would then shift it one fewer bits here, it would be twice as big,\n    // and therefore in the top half of subBucketCount.\n    return <i32>(value >> (bucketIndex + this.unitMagnitude));\n  }\n\n  /**\n   * Get the size (in value units) of the range of values that are equivalent to the given value within the\n   * histogram's resolution. Where \"equivalent\" means that value samples recorded for any two\n   * equivalent values are counted in a common total count.\n   *\n   * @param value The given value\n   * @return The size of the range of values equivalent to the given value.\n   */\n  sizeOfEquivalentValueRange(value: u64): u64 {\n    const bucketIndex = this.getBucketIndex(value);\n    const distanceToNextValue = (<u64>1) << (this.unitMagnitude + bucketIndex);\n    return distanceToNextValue;\n  }\n\n  /**\n   * Get the lowest value that is equivalent to the given value within the histogram's resolution.\n   * Where \"equivalent\" means that value samples recorded for any two\n   * equivalent values are counted in a common total count.\n   *\n   * @param value The given value\n   * @return The lowest value that is equivalent to the given value within the histogram's resolution.\n   */\n  lowestEquivalentValue(value: u64): u64 {\n    const bucketIndex = this.getBucketIndex(value);\n    const subBucketIndex = this.getSubBucketIndex(value, bucketIndex);\n    const thisValueBaseLevel = this.valueFromIndexes(\n      bucketIndex,\n      subBucketIndex\n    );\n    return thisValueBaseLevel;\n  }\n\n  /**\n   * Get the highest value that is equivalent to the given value within the histogram's resolution.\n   * Where \"equivalent\" means that value samples recorded for any two\n   * equivalent values are counted in a common total count.\n   *\n   * @param value The given value\n   * @return The highest value that is equivalent to the given value within the histogram's resolution.\n   */\n  highestEquivalentValue(value: u64): u64 {\n    return this.nextNonEquivalentValue(value) - 1;\n  }\n\n  /**\n   * Get the next value that is not equivalent to the given value within the histogram's resolution.\n   * Where \"equivalent\" means that value samples recorded for any two\n   * equivalent values are counted in a common total count.\n   *\n   * @param value The given value\n   * @return The next value that is not equivalent to the given value within the histogram's resolution.\n   */\n  nextNonEquivalentValue(value: u64): u64 {\n    return (\n      this.lowestEquivalentValue(value) + this.sizeOfEquivalentValueRange(value)\n    );\n  }\n\n  /**\n   * Get a value that lies in the middle (rounded up) of the range of values equivalent the given value.\n   * Where \"equivalent\" means that value samples recorded for any two\n   * equivalent values are counted in a common total count.\n   *\n   * @param value The given value\n   * @return The value lies in the middle (rounded up) of the range of values equivalent the given value.\n   */\n  medianEquivalentValue(value: u64): u64 {\n    return (\n      this.lowestEquivalentValue(value) +\n      (this.sizeOfEquivalentValueRange(value) >> 1)\n    );\n  }\n\n  /**\n   * Get the computed mean value of all recorded values in the histogram\n   *\n   * @return the mean value (in value units) of the histogram data\n   */\n  getMean(): f64 {\n    if (this.totalCount === 0) {\n      return 0;\n    }\n    this.recordedValuesIterator.reset();\n    let totalValue = <u64>0;\n    while (this.recordedValuesIterator.hasNext()) {\n      const iterationValue = this.recordedValuesIterator.next();\n      totalValue +=\n        this.medianEquivalentValue(iterationValue.valueIteratedTo) *\n        iterationValue.countAtValueIteratedTo;\n    }\n\n    return (<f64>totalValue * <f64>1) / <f64>this.totalCount;\n  }\n\n  computeStdDeviation(mean: f64): f64 {\n    if (this.totalCount === 0) {\n      return 0;\n    }\n    let geometric_deviation_total: f64 = 0.0;\n    this.recordedValuesIterator.reset();\n    while (this.recordedValuesIterator.hasNext()) {\n      const iterationValue = this.recordedValuesIterator.next();\n      const deviation =\n        <f64>this.medianEquivalentValue(iterationValue.valueIteratedTo) - mean;\n      geometric_deviation_total +=\n        deviation *\n        deviation *\n        <f64>iterationValue.countAddedInThisIterationStep;\n    }\n    const std_deviation = Math.sqrt(\n      geometric_deviation_total / <f64>this.totalCount\n    );\n    return std_deviation;\n  }\n\n  /**\n   * Get the computed standard deviation of all recorded values in the histogram\n   *\n   * @return the standard deviation (in value units) of the histogram data\n   */\n  getStdDeviation(): f64 {\n    if (this.totalCount === 0) {\n      return 0;\n    }\n    const mean = this.getMean();\n    return this.computeStdDeviation(mean);\n  }\n\n  private updatedMaxValue(value: u64): void {\n    const internalValue: u64 = value + this.unitMagnitudeMask;\n    this.maxValue = internalValue;\n  }\n\n  private updateMinNonZeroValue(value: u64): void {\n    if (value <= this.unitMagnitudeMask) {\n      return;\n    }\n    const internalValue = value & ~this.unitMagnitudeMask; // Min unit-equivalent value;\n    this.minNonZeroValue = internalValue;\n  }\n\n  updateMinAndMax(value: u64): void {\n    if (value > this.maxValue) {\n      this.updatedMaxValue(value);\n    }\n    if (value < this.minNonZeroValue && value !== 0) {\n      this.updateMinNonZeroValue(value);\n    }\n  }\n\n  recordCountAtValue(count: u64, value: u64): void {\n    const countsIndex = this.countsArrayIndex(value);\n    if (countsIndex >= this.countsArrayLength) {\n      this.handleRecordException(count, value);\n    } else {\n      this.addToCountAtIndex(countsIndex, count);\n    }\n    this.updateMinAndMax(value);\n    this.totalCount += count;\n  }\n\n  recordSingleValueWithExpectedInterval(\n    value: u64,\n    expectedIntervalBetweenValueSamples: u64\n  ): void {\n    this.recordSingleValue(value);\n    if (\n      value < expectedIntervalBetweenValueSamples ||\n      expectedIntervalBetweenValueSamples === 0\n    ) {\n      return;\n    }\n    for (\n      let missingValue = value - expectedIntervalBetweenValueSamples;\n      missingValue >= expectedIntervalBetweenValueSamples;\n      missingValue -= expectedIntervalBetweenValueSamples\n    ) {\n      this.recordSingleValue(missingValue);\n    }\n  }\n\n  private recordValueWithCountAndExpectedInterval(\n    value: u64,\n    count: u64,\n    expectedIntervalBetweenValueSamples: u64\n  ): void {\n    this.recordCountAtValue(count, value);\n    if (\n      expectedIntervalBetweenValueSamples <= 0 ||\n      value <= expectedIntervalBetweenValueSamples\n    ) {\n      return;\n    }\n\n    for (\n      let missingValue = value - expectedIntervalBetweenValueSamples;\n      missingValue >= expectedIntervalBetweenValueSamples;\n      missingValue -= expectedIntervalBetweenValueSamples\n    ) {\n      this.recordCountAtValue(count, missingValue);\n    }\n  }\n\n  addWhileCorrectingForCoordinatedOmission(\n    otherHistogram: Histogram<T, U>,\n    expectedIntervalBetweenValueSamples: u64\n  ): void {\n    const toHistogram = this;\n\n    const otherValues = new RecordedValuesIterator<T, U>(otherHistogram);\n\n    while (otherValues.hasNext()) {\n      const v = otherValues.next();\n      toHistogram.recordValueWithCountAndExpectedInterval(\n        v.valueIteratedTo,\n        v.countAtValueIteratedTo,\n        expectedIntervalBetweenValueSamples\n      );\n    }\n  }\n\n  copyCorrectedForCoordinatedOmission(\n    expectedIntervalBetweenValueSamples: u64\n  ): Histogram<T, U> {\n    const copy = new Histogram<T, U>(\n      this.lowestDiscernibleValue,\n      this.highestTrackableValue,\n      this.numberOfSignificantValueDigits\n    );\n    copy.addWhileCorrectingForCoordinatedOmission(\n      this,\n      expectedIntervalBetweenValueSamples\n    );\n    return copy;\n  }\n\n  /**\n   * Get the value at a given percentile.\n   * When the given percentile is &gt; 0.0, the value returned is the value that the given\n   * percentage of the overall recorded value entries in the histogram are either smaller than\n   * or equivalent to. When the given percentile is 0.0, the value returned is the value that all value\n   * entries in the histogram are either larger than or equivalent to.\n   * <p>\n   * Note that two values are \"equivalent\" in this statement if\n   * {@link org.HdrHistogram.AbstractHistogram#valuesAreEquivalent} would return true.\n   *\n   * @param percentile  The percentile for which to return the associated value\n   * @return The value that the given percentage of the overall recorded value entries in the\n   * histogram are either smaller than or equivalent to. When the percentile is 0.0, returns the\n   * value that all value entries in the histogram are either larger than or equivalent to.\n   */\n  getValueAtPercentile(percentile: f64): u64 {\n    const requestedPercentile = min(percentile, <f64>100); // Truncate down to 100%\n\n    // round count up to nearest integer, to ensure that the largest value that the requested percentile\n    // of overall recorded values is actually included. However, this must be done with care:\n    //\n    // First, Compute fp value for count at the requested percentile. Note that fp result end up\n    // being 1 ulp larger than the correct integer count for this percentile:\n    const fpCountAtPercentile =\n      (requestedPercentile / 100.0) * <f64>this.totalCount;\n    // Next, round up, but make sure to prevent <= 1 ulp inaccurancies in the above fp math from\n    // making us skip a count:\n    const countAtPercentile = <u64>max(\n      ceil(fpCountAtPercentile - ulp(fpCountAtPercentile)), // round up\n      1 // Make sure we at least reach the first recorded entry\n    );\n\n    let totalToCurrentIndex: u64 = 0;\n    for (let i = 0; i < this.countsArrayLength; i++) {\n      totalToCurrentIndex += this.getCountAtIndex(i);\n      if (totalToCurrentIndex >= countAtPercentile) {\n        var valueAtIndex: u64 = this.valueFromIndex(i);\n        return percentile === 0.0\n          ? this.lowestEquivalentValue(valueAtIndex)\n          : this.highestEquivalentValue(valueAtIndex);\n      }\n    }\n    return 0;\n  }\n\n  valueFromIndexes(bucketIndex: i32, subBucketIndex: i32): u64 {\n    return (<u64>subBucketIndex) << (bucketIndex + this.unitMagnitude);\n  }\n\n  valueFromIndex(index: i32): u64 {\n    let bucketIndex = (index >> this.subBucketHalfCountMagnitude) - 1;\n    let subBucketIndex =\n      (index & (this.subBucketHalfCount - 1)) + this.subBucketHalfCount;\n    if (bucketIndex < 0) {\n      subBucketIndex -= this.subBucketHalfCount;\n      bucketIndex = 0;\n    }\n    return this.valueFromIndexes(bucketIndex, subBucketIndex);\n  }\n\n  incrementCountAtIndex(index: i32): void {\n    // @ts-ignore\n    const currentCount = unchecked(this.counts[index]);\n    const newCount = currentCount + 1;\n    if (newCount < 0) {\n      throw new Error(\n        newCount.toString() + \" would overflow short integer count\"\n      );\n    }\n    // @ts-ignore\n    unchecked((this.counts[index] = newCount));\n  }\n\n  setCountAtIndex(index: i32, value: u64): void {\n    // @ts-ignore\n    unchecked((this.counts[index] = <U>value));\n  }\n\n  addToCountAtIndex(index: i32, value: u64): void {\n    // @ts-ignore\n    const currentCount = unchecked(this.counts[index]);\n    const newCount = currentCount + value;\n    if (newCount < 0) {\n      throw newCount + \" would overflow short integer count\";\n    }\n    // @ts-ignore\n    unchecked((this.counts[index] = <U>newCount));\n  }\n\n  incrementTotalCount(): void {\n    this.totalCount++;\n  }\n\n  getCountAtIndex(index: i32): u64 {\n    // @ts-ignore\n    return unchecked(<u64>this.counts[index]);\n  }\n\n  resize(newHighestTrackableValue: u64): void {\n    this.establishSize(newHighestTrackableValue);\n    // @ts-ignore\n    this.counts = this.counts.resize(this.countsArrayLength);\n  }\n\n  add<V, W>(otherHistogram: Histogram<V, W>): void {\n    const highestRecordableValue = this.highestEquivalentValue(\n      this.valueFromIndex(this.countsArrayLength - 1)\n    );\n\n    if (highestRecordableValue < otherHistogram.maxValue) {\n      if (!this.autoResize) {\n        throw new Error(\n          \"The other histogram includes values that do not fit in this histogram's range.\"\n        );\n      }\n      this.resize(otherHistogram.maxValue);\n    }\n\n    if (\n      this.bucketCount === otherHistogram.bucketCount &&\n      this.subBucketCount === otherHistogram.subBucketCount &&\n      this.unitMagnitude === otherHistogram.unitMagnitude\n    ) {\n      // Counts arrays are of the same length and meaning, so we can just iterate and add directly:\n      let observedOtherTotalCount = <u64>0;\n      for (let i = 0; i < otherHistogram.countsArrayLength; i++) {\n        const otherCount = otherHistogram.getCountAtIndex(i);\n        if (otherCount > 0) {\n          this.addToCountAtIndex(i, otherCount);\n          observedOtherTotalCount += otherCount;\n        }\n      }\n      this.totalCount += observedOtherTotalCount;\n      this.updatedMaxValue(max(this.maxValue, otherHistogram.maxValue));\n      this.updateMinNonZeroValue(\n        min(this.minNonZeroValue, otherHistogram.minNonZeroValue)\n      );\n    } else {\n      // Arrays are not a direct match (or the other could change on the fly in some valid way),\n      // so we can't just stream through and add them. Instead, go through the array and add each\n      // non-zero value found at it's proper value:\n\n      // Do max value first, to avoid max value updates on each iteration:\n      const otherMaxIndex = otherHistogram.countsArrayIndex(\n        otherHistogram.maxValue\n      );\n      let otherCount = otherHistogram.getCountAtIndex(otherMaxIndex);\n      this.recordCountAtValue(\n        otherCount,\n        otherHistogram.valueFromIndex(otherMaxIndex)\n      );\n\n      // Record the remaining values, up to but not including the max value:\n      for (let i = 0; i < otherMaxIndex; i++) {\n        otherCount = otherHistogram.getCountAtIndex(i);\n        if (otherCount > 0) {\n          this.recordCountAtValue(otherCount, otherHistogram.valueFromIndex(i));\n        }\n      }\n    }\n    this.startTimeStampMsec = min(\n      this.startTimeStampMsec,\n      otherHistogram.startTimeStampMsec\n    );\n    this.endTimeStampMsec = max(\n      this.endTimeStampMsec,\n      otherHistogram.endTimeStampMsec\n    );\n  }\n\n  /**\n   * Get the count of recorded values at a specific value (to within the histogram resolution at the value level).\n   *\n   * @param value The value for which to provide the recorded count\n   * @return The total count of values recorded in the histogram within the value range that is\n   * {@literal >=} lowestEquivalentValue(<i>value</i>) and {@literal <=} highestEquivalentValue(<i>value</i>)\n   */\n  private getCountAtValue(value: u64): u64 {\n    const index = min(\n      max(0, this.countsArrayIndex(value)),\n      this.countsArrayLength - 1\n    );\n    return this.getCountAtIndex(index);\n  }\n\n  establishInternalTackingValues(\n    lengthToCover: i32 = this.countsArrayLength\n  ): void {\n    this.maxValue = 0;\n    this.minNonZeroValue = u64.MAX_VALUE;\n    let maxIndex: i32 = -1;\n    let minNonZeroIndex = -1;\n    let observedTotalCount: u64 = 0;\n    for (let index: i32 = 0; index < lengthToCover; index++) {\n      const countAtIndex: u64 = this.getCountAtIndex(index);\n      if (countAtIndex > 0) {\n        observedTotalCount += countAtIndex;\n        maxIndex = index;\n        if (minNonZeroIndex == -1 && index != 0) {\n          minNonZeroIndex = index;\n        }\n      }\n    }\n    if (maxIndex >= 0) {\n      this.updatedMaxValue(\n        this.highestEquivalentValue(this.valueFromIndex(maxIndex))\n      );\n    }\n    if (minNonZeroIndex >= 0) {\n      this.updateMinNonZeroValue(this.valueFromIndex(minNonZeroIndex));\n    }\n    this.totalCount = observedTotalCount;\n  }\n\n  subtract<V, W>(otherHistogram: Histogram<V, W>): void {\n    const highestRecordableValue = this.valueFromIndex(\n      this.countsArrayLength - 1\n    );\n    if (highestRecordableValue < otherHistogram.maxValue) {\n      if (!this.autoResize) {\n        throw new Error(\n          \"The other histogram includes values that do not fit in this histogram's range.\"\n        );\n      }\n      this.resize(otherHistogram.maxValue);\n    }\n\n    if (\n      this.bucketCount === otherHistogram.bucketCount &&\n      this.subBucketCount === otherHistogram.subBucketCount &&\n      this.unitMagnitude === otherHistogram.unitMagnitude\n    ) {\n      // optim\n      // Counts arrays are of the same length and meaning, so we can just iterate and add directly:\n      let observedOtherTotalCount: u64 = 0;\n      for (let i = 0; i < otherHistogram.countsArrayLength; i++) {\n        const otherCount = otherHistogram.getCountAtIndex(i);\n        if (otherCount > 0) {\n          this.addToCountAtIndex(i, -otherCount);\n          observedOtherTotalCount += otherCount;\n        }\n      }\n      this.totalCount = this.totalCount - observedOtherTotalCount;\n    } else {\n      for (let i = 0; i < otherHistogram.countsArrayLength; i++) {\n        const otherCount = otherHistogram.getCountAtIndex(i);\n        if (otherCount > 0) {\n          const otherValue = otherHistogram.valueFromIndex(i);\n          if (this.getCountAtValue(otherValue) < otherCount) {\n            throw new Error(\n              \"otherHistogram count (\" +\n                otherCount.toString() +\n                \") at value \" +\n                otherValue.toString() +\n                \" is larger than this one's (\" +\n                this.getCountAtValue(otherValue).toString() +\n                \")\"\n            );\n          }\n          this.recordCountAtValue(-otherCount, otherValue);\n        }\n      }\n    }\n    // With subtraction, the max and minNonZero values could have changed:\n    if (\n      this.getCountAtValue(this.maxValue) <= 0 ||\n      this.getCountAtValue(this.minNonZeroValue) <= 0\n    ) {\n      this.establishInternalTackingValues();\n    }\n  }\n\n  /**\n   * Produce textual representation of the value distribution of histogram data by percentile. The distribution is\n   * output with exponentially increasing resolution, with each exponentially decreasing half-distance containing\n   * <i>dumpTicksPerHalf</i> percentile reporting tick points.\n   *\n   * @param printStream    Stream into which the distribution will be output\n   * <p>\n   * @param percentileTicksPerHalfDistance  The number of reporting points per exponentially decreasing half-distance\n   * <p>\n   * @param outputValueUnitScalingRatio    The scaling factor by which to divide histogram recorded values units in\n   *                                     output\n   * @param useCsvFormat  Output in CSV format if true. Otherwise use plain text form.\n   */\n  outputPercentileDistribution(\n    percentileTicksPerHalfDistance: i32 = 5,\n    outputValueUnitScalingRatio: f64 = 1\n  ): string {\n    let result = \"\";\n    result += \"       Value     Percentile TotalCount 1/(1-Percentile)\\n\\n\";\n\n    const iterator = this.percentileIterator;\n    iterator.reset(percentileTicksPerHalfDistance);\n\n    const valueFormatter = new FloatFormatter(\n      12,\n      this.numberOfSignificantValueDigits\n    );\n    const percentileFormatter = new FloatFormatter(2, 12);\n    const totalCountFormatter = new IntegerFormatter(10);\n    const lastFormatter = new FloatFormatter(14, 2);\n\n    while (iterator.hasNext()) {\n      const iterationValue = iterator.next();\n      if (iterationValue.percentileLevelIteratedTo < 100) {\n        result +=\n          valueFormatter.format(\n            <f64>iterationValue.valueIteratedTo / outputValueUnitScalingRatio\n          ) +\n          \" \" +\n          percentileFormatter.format(\n            iterationValue.percentileLevelIteratedTo / <f64>100\n          ) +\n          \" \" +\n          totalCountFormatter.format(iterationValue.totalCountToThisValue) +\n          \" \" +\n          lastFormatter.format(\n            <f64>1 /\n              (<f64>1 - iterationValue.percentileLevelIteratedTo / <f64>100)\n          ) +\n          \"\\n\";\n      } else {\n        result +=\n          valueFormatter.format(\n            <f64>iterationValue.valueIteratedTo / outputValueUnitScalingRatio\n          ) +\n          \" \" +\n          percentileFormatter.format(\n            iterationValue.percentileLevelIteratedTo / <f64>100\n          ) +\n          \" \" +\n          totalCountFormatter.format(iterationValue.totalCountToThisValue) +\n          \"\\n\";\n      }\n    }\n\n    // Calculate and output mean and std. deviation.\n    // Note: mean/std. deviation numbers are very often completely irrelevant when\n    // data is extremely non-normal in distribution (e.g. in cases of strong multi-modal\n    // response time distribution associated with GC pauses). However, reporting these numbers\n    // can be very useful for contrasting with the detailed percentile distribution\n    // reported by outputPercentileDistribution(). It is not at all surprising to find\n    // percentile distributions where results fall many tens or even hundreds of standard\n    // deviations away from the mean - such results simply indicate that the data sampled\n    // exhibits a very non-normal distribution, highlighting situations for which the std.\n    // deviation metric is a useless indicator.\n    //\n    const formatter = new FloatFormatter(\n      12,\n      this.numberOfSignificantValueDigits\n    );\n    const _mean = this.getMean();\n    const mean = formatter.format(_mean / outputValueUnitScalingRatio);\n    const std_deviation = formatter.format(\n      this.computeStdDeviation(_mean) / outputValueUnitScalingRatio\n    );\n    const max = formatter.format(\n      <f64>this.maxValue / outputValueUnitScalingRatio\n    );\n    const intFormatter = new IntegerFormatter(12);\n    const totalCount = intFormatter.format(this.totalCount);\n    const bucketCount = intFormatter.format(this.bucketCount);\n    const subBucketCount = intFormatter.format(this.subBucketCount);\n    // #[Mean    =         50.0,\n    // #[Mean    =       50.000,\n    result +=\n      `#[Mean    = ` +\n      mean.toString() +\n      `, StdDeviation   = ` +\n      std_deviation.toString() +\n      `]\n#[Max     = ` +\n      max.toString() +\n      `, Total count    = ` +\n      totalCount.toString() +\n      `]\n#[Buckets = ` +\n      bucketCount.toString() +\n      `, SubBuckets     = ` +\n      subBucketCount.toString() +\n      `]\n`;\n\n    return result;\n  }\n\n  encode(): Uint8Array {\n    const buffer = ByteBuffer.allocate(1024);\n    encodeIntoByteBuffer(this, buffer);\n    return buffer.data.slice(0, buffer.position);\n  }\n\n  public get estimatedFootprintInBytes(): i32 {\n    // @ts-ignore\n    return offsetof<Histogram<T, U>>() + this.counts.estimatedFootprintInBytes;\n  }\n\n  clearCounts(): void {\n    // @ts-ignore\n    this.counts.clear();\n  }\n\n  reset(): void {\n    this.clearCounts();\n    this.totalCount = 0;\n    this.startTimeStampMsec = 0;\n    this.endTimeStampMsec = 0;\n    //this.tag = NO_TAG;\n    this.maxValue = 0;\n    this.minNonZeroValue = U64.MAX_VALUE;\n  }\n}\n\nexport class Storage<T, U> {\n  [key: number]: number;\n  array: T;\n  constructor(size: i32) {\n    this.array = instantiate<T>(size);\n  }\n\n  public get estimatedFootprintInBytes(): i32 {\n    // @ts-ignore\n    return offsetof<Storage<T, U>>() + this.array.byteLength;\n  }\n\n  resize(newSize: i32): Storage<T, U> {\n    const newArray = new Storage<T, U>(newSize);\n    // @ts-ignore\n    newArray.array.set(this.array);\n    return newArray;\n  }\n\n  clear(): void {\n    // @ts-ignore\n    this.array.fill(0);\n  }\n\n  @operator(\"[]\") private __get(index: i32): U {\n    // @ts-ignore\n    return unchecked(this.array[index]);\n  }\n\n  @operator(\"[]=\") private __set(index: i32, value: U): void {\n    // @ts-ignore\n    unchecked((this.array[index] = value));\n  }\n}\n\nexport type Uint8Storage = Storage<Uint8Array, u8>;\nexport type Uint16Storage = Storage<Uint16Array, u16>;\nexport type Uint32Storage = Storage<Uint32Array, u32>;\nexport type Uint64Storage = Storage<Uint64Array, u64>;\n\nexport class Histogram8 extends Histogram<Uint8Storage, u8> {}\nexport class Histogram16 extends Histogram<Uint16Storage, u16> {}\nexport class Histogram32 extends Histogram<Uint32Storage, u32> {}\nexport class Histogram64 extends Histogram<Uint64Storage, u64> {}\nexport class PackedHistogram extends Histogram<PackedArray, u64> {}\n","/// <reference path=\"./rt/index.d.ts\" />\n\nimport { BLOCK, BLOCK_MAXSIZE, BLOCK_OVERHEAD } from \"./rt/common\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n  readonly buffer: ArrayBuffer;\n  @unsafe readonly dataStart: usize;\n  readonly byteLength: i32;\n\n  get byteOffset(): i32 {\n    return <i32>(this.dataStart - changetype<usize>(this.buffer));\n  }\n\n  protected constructor(length: i32, alignLog2: i32) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n    var buffer = __alloc(length = length << alignLog2, idof<ArrayBuffer>());\n    memory.fill(buffer, 0, <usize>length);\n    this.buffer = changetype<ArrayBuffer>(buffer); // retains\n    this.dataStart = buffer;\n    this.byteLength = length;\n  }\n}\n\n@final export class ArrayBuffer {\n\n  static isView<T>(value: T): bool {\n    if (isNullable<T>()) {\n      if (value === null) return false;\n    }\n    if (value instanceof Int8Array) return true;\n    if (value instanceof Uint8Array) return true;\n    if (value instanceof Uint8ClampedArray) return true;\n    if (value instanceof Int16Array) return true;\n    if (value instanceof Uint16Array) return true;\n    if (value instanceof Int32Array) return true;\n    if (value instanceof Uint32Array) return true;\n    if (value instanceof Int64Array) return true;\n    if (value instanceof Uint64Array) return true;\n    if (value instanceof Float32Array) return true;\n    if (value instanceof Float64Array) return true;\n    if (value instanceof DataView) return true;\n    return false;\n  }\n\n  constructor(length: i32) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n    var buffer = __alloc(<usize>length, idof<ArrayBuffer>());\n    memory.fill(buffer, 0, <usize>length);\n    return changetype<ArrayBuffer>(buffer); // retains\n  }\n\n  get byteLength(): i32 {\n    return changetype<BLOCK>(changetype<usize>(this) - BLOCK_OVERHEAD).rtSize;\n  }\n\n  slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n    var length = this.byteLength;\n    begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n    end   = end   < 0 ? max(length + end  , 0) : min(end  , length);\n    var outSize = <usize>max(end - begin, 0);\n    var out = __alloc(outSize, idof<ArrayBuffer>());\n    memory.copy(out, changetype<usize>(this) + <usize>begin, outSize);\n    return changetype<ArrayBuffer>(out); // retains\n  }\n\n  toString(): string {\n    return \"[object ArrayBuffer]\";\n  }\n}\n","import { COMPARATOR, SORT as SORT_IMPL } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n  [key: number]: i8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i8>();\n\n  constructor(length: i32) {\n    super(length, alignof<i8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i8 {\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<i8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i8>(this.dataStart + <usize>index, value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<i8>): void {\n    store<i8>(this.dataStart + <usize>index, value);\n  }\n\n  includes(searchElement: i8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return FILL<Int8Array, i8>(this, value, start, end);\n  }\n\n  sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR<i8>()): Int8Array {\n    return SORT<Int8Array, i8>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return SLICE<Int8Array, i8>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return SUBARRAY<Int8Array, i8>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n    return COPY_WITHIN<Int8Array, i8>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int8Array, i8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int8Array, i8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n    return MAP<Int8Array, i8>(this, fn);\n  }\n\n  filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n    return FILTER<Int8Array, i8>(this, fn);\n  }\n\n  findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n    return FIND_INDEX<Int8Array, i8>(this, fn);\n  }\n\n  some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n    return SOME<Int8Array, i8>(this, fn);\n  }\n\n  every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n    return EVERY<Int8Array, i8>(this, fn);\n  }\n\n  forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n    FOREACH<Int8Array, i8>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, i8>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i8>(this.dataStart, this.length, separator);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Int8Array, i8, U, valueof<U>>(this, source, offset);\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n    return WRAP<Int8Array, i8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n  [key: number]: u8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();\n\n  constructor(length: i32) {\n    super(length, alignof<u8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u8 {\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u8>(this.dataStart + <usize>index, value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u8>): void {\n    store<u8>(this.dataStart + <usize>index, value);\n  }\n\n  includes(searchElement: u8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return FILL<Uint8Array, u8>(this, value, start, end);\n  }\n\n  sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8Array {\n    return SORT<Uint8Array, u8>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return SLICE<Uint8Array, u8>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return SUBARRAY<Uint8Array, u8>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return COPY_WITHIN<Uint8Array, u8>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint8Array, u8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint8Array, u8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n    return MAP<Uint8Array, u8>(this, fn);\n  }\n\n  filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n    return FILTER<Uint8Array, u8>(this, fn);\n  }\n\n  findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n    return FIND_INDEX<Uint8Array, u8>(this, fn);\n  }\n\n  some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n    return SOME<Uint8Array, u8>(this, fn);\n  }\n\n  every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n    return EVERY<Uint8Array, u8>(this, fn);\n  }\n\n  forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n    FOREACH<Uint8Array, u8>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u8>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u8>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint8Array, u8, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n    return WRAP<Uint8Array, u8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n  [key: number]: u8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();\n\n  constructor(length: i32) {\n    super(length, alignof<u8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u8 {\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u8>): void {\n    store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));\n  }\n\n  includes(searchElement: u8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return FILL<Uint8ClampedArray, u8>(this, value, start, end);\n  }\n\n  sort(fn: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8ClampedArray {\n    return SORT<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return SLICE<Uint8ClampedArray, u8>(this, begin, end);\n  }\n\n  subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return SUBARRAY<Uint8ClampedArray, u8>(this, start, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return COPY_WITHIN<Uint8ClampedArray, u8>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint8ClampedArray, u8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n    return MAP<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n    return FILTER<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n    return FIND_INDEX<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n    return SOME<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n    return EVERY<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n    FOREACH<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u8>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u8>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint8ClampedArray, u8, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n    return WRAP<Uint8ClampedArray, u8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int16Array extends ArrayBufferView {\n  [key: number]: i16;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i16>();\n\n  constructor(length: i32) {\n    super(length, alignof<i16>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i16>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i16 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i16 {\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<i16>): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<i16>): void {\n    store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);\n  }\n\n  includes(searchElement: i16, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return FILL<Int16Array, i16>(this, value, start, end);\n  }\n\n  sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR<i16>()): Int16Array {\n    return SORT<Int16Array, i16>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return SLICE<Int16Array, i16>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return SUBARRAY<Int16Array, i16>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n    return COPY_WITHIN<Int16Array, i16>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int16Array, i16, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int16Array, i16, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n    return MAP<Int16Array, i16>(this, fn);\n  }\n\n  filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n    return FILTER<Int16Array, i16>(this, fn);\n  }\n\n  findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n    return FIND_INDEX<Int16Array, i16>(this, fn);\n  }\n\n  some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n    return SOME<Int16Array, i16>(this, fn);\n  }\n\n  every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n    return EVERY<Int16Array, i16>(this, fn);\n  }\n\n  forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n    FOREACH<Int16Array, i16>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, i16>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i16>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Int16Array, i16, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n    return WRAP<Int16Array, i16>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n  [key: number]: u16;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u16>();\n\n  constructor(length: i32) {\n    super(length, alignof<u16>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u16>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u16 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u16 {\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u16>): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u16>): void {\n    store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);\n  }\n\n  includes(searchElement: u16, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return FILL<Uint16Array, u16>(this, value, start, end);\n  }\n\n  sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR<u16>()): Uint16Array {\n    return SORT<Uint16Array, u16>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return SLICE<Uint16Array, u16>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return SUBARRAY<Uint16Array, u16>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return COPY_WITHIN<Uint16Array, u16>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint16Array, u16, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint16Array, u16, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n    return MAP<Uint16Array, u16>(this, fn);\n  }\n\n  filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n    return FILTER<Uint16Array, u16>(this, fn);\n  }\n\n  findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n    return FIND_INDEX<Uint16Array, u16>(this, fn);\n  }\n\n  some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n    return SOME<Uint16Array, u16>(this, fn);\n  }\n\n  every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n    return EVERY<Uint16Array, u16>(this, fn);\n  }\n\n  forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n    FOREACH<Uint16Array, u16>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u16>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u16>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint16Array, u16, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n    return WRAP<Uint16Array, u16>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int32Array extends ArrayBufferView {\n  [key: number]: i32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i32>();\n\n  constructor(length: i32) {\n    super(length, alignof<i32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i32 {\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: i32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: i32): void {\n    store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);\n  }\n\n  includes(searchElement: i32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return FILL<Int32Array, i32>(this, value, start, end);\n  }\n\n  sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR<i32>()): Int32Array {\n    return SORT<Int32Array, i32>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return SLICE<Int32Array, i32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return SUBARRAY<Int32Array, i32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n    return COPY_WITHIN<Int32Array, i32>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int32Array, i32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int32Array, i32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n    return MAP<Int32Array, i32>(this, fn);\n  }\n\n  filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n    return FILTER<Int32Array, i32>(this, fn);\n  }\n\n  findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n    return FIND_INDEX<Int32Array, i32>(this, fn);\n  }\n\n  some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n    return SOME<Int32Array, i32>(this, fn);\n  }\n\n  every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n    return EVERY<Int32Array, i32>(this, fn);\n  }\n\n  forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n    FOREACH<Int32Array, i32>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, i32>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Int32Array, i32, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n    return WRAP<Int32Array, i32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n  [key: number]: u32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u32>();\n\n  constructor(length: i32) {\n    super(length, alignof<u32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u32 {\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: u32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: u32): void {\n    store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);\n  }\n\n  includes(searchElement: u32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return FILL<Uint32Array, u32>(this, value, start, end);\n  }\n\n  sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR<u32>()): Uint32Array {\n    return SORT<Uint32Array, u32>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return SLICE<Uint32Array, u32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return SUBARRAY<Uint32Array, u32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return COPY_WITHIN<Uint32Array, u32>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint32Array, u32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint32Array, u32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n    return MAP<Uint32Array, u32>(this, fn);\n  }\n\n  filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n    return FILTER<Uint32Array, u32>(this, fn);\n  }\n\n  findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n    return FIND_INDEX<Uint32Array, u32>(this, fn);\n  }\n\n  some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n    return SOME<Uint32Array, u32>(this, fn);\n  }\n\n  every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n    return EVERY<Uint32Array, u32>(this, fn);\n  }\n\n  forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n    FOREACH<Uint32Array, u32>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u32>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint32Array, u32, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n    return WRAP<Uint32Array, u32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int64Array extends ArrayBufferView {\n  [key: number]: i64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i64>();\n\n  constructor(length: i32) {\n    super(length, alignof<i64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i64 {\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: i64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: i64): void {\n    store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);\n  }\n\n  includes(searchElement: i64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return FILL<Int64Array, i64>(this, value, start, end);\n  }\n\n  sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR<i64>()): Int64Array {\n    return SORT<Int64Array, i64>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return SLICE<Int64Array, i64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return SUBARRAY<Int64Array, i64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n    return COPY_WITHIN<Int64Array, i64>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int64Array, i64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int64Array, i64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n    return MAP<Int64Array, i64>(this, fn);\n  }\n\n  filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n    return FILTER<Int64Array, i64>(this, fn);\n  }\n\n  findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n    return FIND_INDEX<Int64Array, i64>(this, fn);\n  }\n\n  some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n    return SOME<Int64Array, i64>(this, fn);\n  }\n\n  every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n    return EVERY<Int64Array, i64>(this, fn);\n  }\n\n  forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n    FOREACH<Int64Array, i64>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, i64>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Int64Array, i64, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n    return WRAP<Int64Array, i64>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n  [key: number]: u64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u64>();\n\n  constructor(length: i32) {\n    super(length, alignof<u64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u64 {\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: u64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: u64): void {\n    store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);\n  }\n\n  includes(searchElement: u64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return FILL<Uint64Array, u64>(this, value, start, end);\n  }\n\n  sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR<u64>()): Uint64Array {\n    return SORT<Uint64Array, u64>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return SLICE<Uint64Array, u64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return SUBARRAY<Uint64Array, u64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return COPY_WITHIN<Uint64Array, u64>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint64Array, u64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint64Array, u64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n    return MAP<Uint64Array, u64>(this, fn);\n  }\n\n  filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n    return FILTER<Uint64Array, u64>(this, fn);\n  }\n\n  findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n    return FIND_INDEX<Uint64Array, u64>(this, fn);\n  }\n\n  some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n    return SOME<Uint64Array, u64>(this, fn);\n  }\n\n  every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n    return EVERY<Uint64Array, u64>(this, fn);\n  }\n\n  forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n    FOREACH<Uint64Array, u64>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u64>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint64Array, u64, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n    return WRAP<Uint64Array, u64>(buffer, byteOffset, length);\n  }\n}\n\nexport class Float32Array extends ArrayBufferView {\n  [key: number]: f32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<f32>();\n\n  constructor(length: i32) {\n    super(length, alignof<f32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<f32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): f32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): f32 {\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: f32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: f32): void {\n    store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);\n  }\n\n  includes(searchElement: f32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return FILL<Float32Array, f32>(this, value, start, end);\n  }\n\n  sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR<f32>()): Float32Array {\n    return SORT<Float32Array, f32>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return SLICE<Float32Array, f32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return SUBARRAY<Float32Array, f32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n    return COPY_WITHIN<Float32Array, f32>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Float32Array, f32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Float32Array, f32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n    return MAP<Float32Array, f32>(this, fn);\n  }\n\n  filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n    return FILTER<Float32Array, f32>(this, fn);\n  }\n\n  findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n    return FIND_INDEX<Float32Array, f32>(this, fn);\n  }\n\n  some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n    return SOME<Float32Array, f32>(this, fn);\n  }\n\n  every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n    return EVERY<Float32Array, f32>(this, fn);\n  }\n\n  forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n    FOREACH<Float32Array, f32>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, f32>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinFloatArray<f32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Float32Array, f32, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n    return WRAP<Float32Array, f32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Float64Array extends ArrayBufferView {\n  [key: number]: f64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<f64>();\n\n  constructor(length: i32) {\n    super(length, alignof<f64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<f64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): f64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): f64 {\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: f64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: f64): void {\n    store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);\n  }\n\n  includes(searchElement: f64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return FILL<Float64Array, f64>(this, value, start, end);\n  }\n\n  sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR<f64>()): Float64Array {\n    return SORT<Float64Array, f64>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return SLICE<Float64Array, f64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return SUBARRAY<Float64Array, f64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n    return COPY_WITHIN<Float64Array, f64>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Float64Array, f64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Float64Array, f64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n    return MAP<Float64Array, f64>(this, fn);\n  }\n\n  filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n    return FILTER<Float64Array, f64>(this, fn);\n  }\n\n  findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n    return FIND_INDEX<Float64Array, f64>(this, fn);\n  }\n\n  some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n    return SOME<Float64Array, f64>(this, fn);\n  }\n\n  every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n    return EVERY<Float64Array, f64>(this, fn);\n  }\n\n  forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n    FOREACH<Float64Array, f64>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, f64>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinFloatArray<f64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Float64Array, f64, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n    return WRAP<Float64Array, f64>(buffer, byteOffset, length);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILL<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  value: native<T>,\n  start: i32,\n  end: i32\n): TArray {\n  var dataStart = array.dataStart;\n  var len = array.length;\n  start = start < 0 ? max(len + start, 0) : min(start, len);\n  end   = end   < 0 ? max(len + end,   0) : min(end,   len);\n  if (sizeof<T>() == 1) {\n    if (start < end) memory.fill(dataStart + <usize>start, <u8>value, <usize>(end - start));\n  } else {\n    for (; start < end; ++start) {\n      store<T>(dataStart + (<usize>start << alignof<T>()), value);\n    }\n  }\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SORT<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  comparator: (a: T, b: T) => i32\n): TArray {\n  var len = array.length;\n  if (len <= 1) return array;\n  var base = array.dataStart;\n  if (len == 2) {\n    let a: T = load<T>(base, sizeof<T>()); // a = arr[1]\n    let b: T = load<T>(base); // b = arr[0]\n    if (comparator(a, b) < 0) {\n      store<T>(base, b, sizeof<T>()); // arr[1] = b\n      store<T>(base, a); // arr[0] = a\n    }\n    return array;\n  }\n  SORT_IMPL<T>(base, len, comparator);\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  start: i32,\n  end: i32\n): TArray {\n  var len = array.length;\n  start  = start < 0 ? max(start + len, 0) : min(start, len);\n  end    = end   < 0 ? max(end   + len, 0) : min(end  , len);\n  len = max(end - start, 0);\n  var slice = instantiate<TArray>(len);\n  memory.copy(\n    slice.dataStart,\n    array.dataStart + (<usize>start << alignof<T>()),\n    <usize>len << alignof<T>()\n  );\n  return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  begin: i32,\n  end: i32\n): TArray {\n  var len = array.length;\n  begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n  end   = end   < 0 ? max(len + end,   0) : min(end,   len);\n  end   = max(end, begin);\n\n  var out = __alloc(offsetof<TArray>(), idof<TArray>());\n  store<usize>(out, __retain(changetype<usize>(array.buffer)), offsetof<TArray>(\"buffer\"));\n  store<usize>(out, array.dataStart + (<usize>begin << alignof<T>()), offsetof<TArray>(\"dataStart\"));\n  store<u32>(out, (end - begin) << alignof<T>(), offsetof<TArray>(\"byteLength\"));\n  return changetype<TArray>(out); // retains\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  target: i32,\n  start: i32,\n  end: i32\n): TArray {\n  var len = array.length;\n  var dataStart = array.dataStart;\n\n  end   = min<i32>(end, len);\n  var to    = target < 0 ? max(len + target, 0) : min(target, len);\n  var from  = start < 0 ? max(len + start, 0) : min(start, len);\n  var last  = end < 0 ? max(len + end, 0) : min(end, len);\n  var count = min(last - from, len - to);\n\n  memory.copy(\n    dataStart + (<usize>to << alignof<T>()),\n    dataStart + (<usize>from << alignof<T>()),\n    <usize>count << alignof<T>()\n  );\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE<TArray extends ArrayBufferView, T, TRet>(\n  array: TArray,\n  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n  initialValue: TRet\n): TRet {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    initialValue = fn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);\n  }\n  return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT<TArray extends ArrayBufferView, T, TRet>(\n  array: TArray,\n  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n  initialValue: TRet\n): TRet {\n  var dataStart = array.dataStart;\n  for (let i = array.length - 1; i >= 0; i--) {\n    initialValue = fn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);\n  }\n  return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n  var len = array.length;\n  var dataStart = array.dataStart;\n\n  var byteLength = len << alignof<T>();\n  var out = __alloc(offsetof<TArray>(), idof<TArray>());\n  var buffer = __alloc(byteLength, idof<ArrayBuffer>());\n  for (let i = 0; i < len; i++) {\n    store<T>(\n      buffer + (<usize>i << alignof<T>()),\n      fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)\n    );\n  }\n  store<usize>(out, __retain(buffer), offsetof<TArray>(\"buffer\"));\n  store<usize>(out, buffer, offsetof<TArray>(\"dataStart\"));\n  store<u32>(out, byteLength, offsetof<TArray>(\"byteLength\"));\n  return changetype<TArray>(out); // retains\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n  var len = array.length;\n  var out = __alloc(offsetof<TArray>(), idof<TArray>());\n  var buffer = __alloc(len << alignof<T>(), idof<ArrayBuffer>());\n  var dataStart  = array.dataStart;\n  var j: usize = 0;\n  for (let i = 0; i < len; i++) {\n    let value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    if (fn(value, i, array)) {\n      store<T>(\n        buffer + (j++ << alignof<T>()),\n        value\n      );\n    }\n  }\n  // shrink output buffer\n  var byteLength = j << alignof<T>();\n  var data = __realloc(buffer, byteLength);\n  store<usize>(out, __retain(data), offsetof<TArray>(\"buffer\"));\n  store<u32>(out, byteLength, offsetof<TArray>(\"byteLength\"));\n  store<usize>(out, data, offsetof<TArray>(\"dataStart\"));\n  return changetype<TArray>(out); // retains\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return i;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): bool {\n  if (isFloat<T>()) {\n    let index: isize = fromIndex;\n    let length: isize = array.length;\n    if (length == 0 || index >= length) return false;\n    if (index < 0) index = max(length + index, 0);\n    let dataStart = array.dataStart;\n    while (index < length) {\n      let elem = load<T>(dataStart + (index << alignof<T>()));\n      // @ts-ignore\n      if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n      ++index;\n    }\n    return false;\n  } else {\n    return INDEX_OF<TArray, T>(array, searchElement, fromIndex) >= 0;\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): i32 {\n  var index: isize = fromIndex;\n  var length: isize = array.length;\n  if (length == 0 || index >= length) return -1;\n  if (index < 0) index = max(length + index, 0);\n  var dataStart = array.dataStart;\n  while (index < length) {\n    if (load<T>(dataStart + (index << alignof<T>())) == searchElement) return <i32>index;\n    ++index;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): i32 {\n  var index: isize = fromIndex;\n  var length: isize = array.length;\n  if (length == 0) return -1;\n  if (index < 0) index = length + index; // no need to clamp\n  else if (index >= length) index = length - 1;\n  var dataStart = array.dataStart;\n  while (index >= 0) {\n    if (load<T>(dataStart + (index << alignof<T>())) == searchElement) return <i32>index;\n    --index;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return true;\n  }\n  return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) continue;\n    return false;\n  }\n  return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => void,\n): void {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REVERSE<TArray extends ArrayBufferView, T>(array: TArray): TArray {\n  var dataStart = array.dataStart;\n  for (let front: usize = 0, back: usize = array.length - 1; front < back; ++front, --back) {\n    let frontPtr = dataStart + (front << alignof<T>());\n    let backPtr = dataStart + (back << alignof<T>());\n    let temp = load<T>(frontPtr);\n    store<T>(frontPtr, load<T>(backPtr));\n    store<T>(backPtr, temp);\n  }\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP<TArray extends ArrayBufferView, T>(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): TArray {\n  var byteLength: i32;\n  var bufferByteLength = buffer.byteLength;\n  const mask: u32 = sizeof<T>() - 1;\n  if (i32(<u32>byteOffset > <u32>bufferByteLength) | (byteOffset & mask)) {\n    throw new RangeError(E_INDEXOUTOFRANGE);\n  }\n  if (length < 0) {\n    if (length == -1) {\n      if (bufferByteLength & mask) {\n        throw new RangeError(E_INVALIDLENGTH);\n      }\n      byteLength = bufferByteLength - byteOffset;\n    } else {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n  } else {\n    byteLength = length << alignof<T>();\n    if (byteOffset + byteLength > bufferByteLength) {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n  }\n  var out = __alloc(offsetof<TArray>(), idof<TArray>());\n  store<usize>(out, __retain(changetype<usize>(buffer)), offsetof<TArray>(\"buffer\"));\n  store<u32>(out, byteLength, offsetof<TArray>(\"byteLength\"));\n  store<usize>(out, changetype<usize>(buffer) + <usize>byteOffset, offsetof<TArray>(\"dataStart\"));\n  return changetype<TArray>(out); // retains\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<TArray extends ArrayBufferView, T, UArray extends ArrayBufferView, U>(target: TArray, source: UArray, offset: i32 = 0): void {\n  // need to assert at compile time that U is not a reference or a function\n  if (isReference<U>()) {\n    ERROR(E_NOTIMPLEMENTED);\n  }\n\n  // Uncaught RangeError: offset is out of bounds\n  if (offset < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n  if (source.length + offset > target.length) throw new RangeError(E_INDEXOUTOFRANGE);\n\n  // if the types align and match, use memory.copy() instead of manual loop\n  if (isInteger<T>() == isInteger<U>() && alignof<T>() == alignof<U>() &&\n    !(target instanceof Uint8ClampedArray && isSigned<U>())) {\n    memory.copy(\n      target.dataStart + (<usize>offset << alignof<T>()),\n      source.dataStart,\n      source.byteLength\n    );\n  } else {\n    let targetDataStart = target.dataStart + (<usize>offset << alignof<T>());\n    let sourceDataStart = source.dataStart;\n    let count = source.length;\n    for (let i = 0; i < count; i++) {\n      // if TArray is Uint8ClampedArray, then values must be clamped\n      if (target instanceof Uint8ClampedArray) {\n        if (isFloat<U>()) {\n          let value = load<U>(sourceDataStart + (<usize>i << alignof<U>()));\n          store<T>(\n            targetDataStart + (<usize>i << alignof<T>()),\n            isFinite<U>(value) ? <T>max<U>(0, min<U>(255, value)) : 0\n          );\n        } else {\n          let value = load<U>(sourceDataStart + (<usize>i << alignof<U>()));\n          if (!isSigned<U>()) {\n            store<T>(\n              targetDataStart + (<usize>i << alignof<T>()),\n              // @ts-ignore: cast to T is valid for numeric types here\n              min<U>(255, value)\n            );\n          } else if (sizeof<T>() <= 4) {\n            store<T>(\n              targetDataStart + (<usize>i << alignof<T>()),\n              // @ts-ignore: cast to T is valid for numeric types here\n              ~(<i32>value >> 31) & (((255 - <i32>value) >> 31) | value)\n            );\n          } else {\n            store<T>(\n              targetDataStart + (<usize>i << alignof<T>()),\n              // @ts-ignore: cast to T is valid for numeric types here\n              ~(<i64>value >> 63) & (((255 - <i64>value) >> 63) | value)\n            );\n          }\n        }\n        // if U is a float, then casting float to int must include a finite check\n      } else if (isFloat<U>() && !isFloat<T>()) {\n        let value = load<U>(sourceDataStart + (<usize>i << alignof<U>()));\n        // @ts-ignore: cast to T is valid for numeric types here\n        store<T>(targetDataStart + (<usize>i << alignof<T>()), isFinite<U>(value) ? <T>value : 0);\n      } else if (isFloat<T>() && !isFloat<U>()) {\n        // @ts-ignore: In this case the <T> conversion is required\n        store<T>(targetDataStart + (<usize>i << alignof<T>()), <T>load<U>(sourceDataStart + (<usize>i << alignof<U>())));\n      } else {\n        store<T>(targetDataStart + (<usize>i << alignof<T>()), load<U>(sourceDataStart + (<usize>i << alignof<U>())));\n      }\n    }\n  }\n}\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport Histogram from \"./Histogram\";\nimport HistogramIterationValue from \"./HistogramIterationValue\";\n\n/**\n * Used for iterating through histogram values according to percentile levels. The iteration is\n * performed in steps that start at 0% and reduce their distance to 100% according to the\n * <i>percentileTicksPerHalfDistance</i> parameter, ultimately reaching 100% when all recorded histogram\n * values are exhausted.\n */\nclass PercentileIterator<T, U> {\n  percentileTicksPerHalfDistance: i32;\n  percentileLevelToIterateTo: f64;\n  percentileLevelToIterateFrom: f64;\n  reachedLastRecordedValue: boolean;\n  histogram: Histogram<T, U>;\n  savedHistogramTotalRawCount: u64;\n  currentIndex: i32;\n  currentValueAtIndex: u64;\n  nextValueAtIndex: u64;\n  prevValueIteratedTo: u64;\n  totalCountToPrevIndex: u64;\n  totalCountToCurrentIndex: u64;\n  totalValueToCurrentIndex: u64;\n  arrayTotalCount: u64;\n  countAtThisValue: u64;\n\n  private freshSubBucket: boolean;\n\n  currentIterationValue: HistogramIterationValue = new HistogramIterationValue();\n\n  /**\n   * @param histogram The histogram this iterator will operate on\n   * @param percentileTicksPerHalfDistance The number of equal-sized iteration steps per half-distance to 100%.\n   */\n  public constructor(\n    histogram: Histogram<T, U>,\n    percentileTicksPerHalfDistance: i32\n  ) {\n    this.percentileTicksPerHalfDistance = 0;\n    this.percentileLevelToIterateTo = 0;\n    this.percentileLevelToIterateFrom = 0;\n    this.reachedLastRecordedValue = false;\n    this.doReset(histogram, percentileTicksPerHalfDistance);\n  }\n\n  /**\n   * Reset iterator for re-use in a fresh iteration over the same histogram data set.\n   *\n   * @param percentileTicksPerHalfDistance The number of iteration steps per half-distance to 100%.\n   */\n  reset(percentileTicksPerHalfDistance: i32): void {\n    this.doReset(this.histogram, percentileTicksPerHalfDistance);\n  }\n\n  private doReset(\n    histogram: Histogram<T, U>,\n    percentileTicksPerHalfDistance: i32\n  ): void {\n    this.resetIterator(histogram);\n    this.percentileTicksPerHalfDistance = percentileTicksPerHalfDistance;\n    this.percentileLevelToIterateTo = 0;\n    this.percentileLevelToIterateFrom = 0;\n    this.reachedLastRecordedValue = false;\n  }\n\n  incrementIterationLevel(): void {\n    this.percentileLevelToIterateFrom = this.percentileLevelToIterateTo;\n\n    // The choice to maintain fixed-sized \"ticks\" in each half-distance to 100% [starting\n    // from 0%], as opposed to a \"tick\" size that varies with each interval, was made to\n    // make the steps easily comprehensible and readable to humans. The resulting percentile\n    // steps are much easier to browse through in a percentile distribution output, for example.\n    //\n    // We calculate the number of equal-sized \"ticks\" that the 0-100 range will be divided\n    // by at the current scale. The scale is detemined by the percentile level we are\n    // iterating to. The following math determines the tick size for the current scale,\n    // and maintain a fixed tick size for the remaining \"half the distance to 100%\"\n    // [from either 0% or from the previous half-distance]. When that half-distance is\n    // crossed, the scale changes and the tick size is effectively cut in half.\n\n    // percentileTicksPerHalfDistance = 5\n    // percentileReportingTicks = 10,\n\n    const percentileReportingTicks =\n      <f64>this.percentileTicksPerHalfDistance *\n      Math.pow(\n        2,\n        floor(\n          Math.log2(<f64>100 / (<f64>100 - this.percentileLevelToIterateTo))\n        ) + <f64>1\n      );\n\n    this.percentileLevelToIterateTo += <f64>100 / percentileReportingTicks;\n  }\n\n  reachedIterationLevel(): boolean {\n    if (this.countAtThisValue === 0) {\n      return false;\n    }\n    const currentPercentile =\n      (<f64>100 * <f64>this.totalCountToCurrentIndex) /\n      <f64>this.arrayTotalCount;\n    return currentPercentile >= this.percentileLevelToIterateTo;\n  }\n\n  resetIterator(histogram: Histogram<T, U>): void {\n    this.histogram = histogram;\n    this.savedHistogramTotalRawCount = histogram.totalCount;\n    this.arrayTotalCount = histogram.totalCount;\n    this.currentIndex = 0;\n    this.currentValueAtIndex = 0;\n    this.nextValueAtIndex = 1 << histogram.unitMagnitude;\n    this.prevValueIteratedTo = 0;\n    this.totalCountToPrevIndex = 0;\n    this.totalCountToCurrentIndex = 0;\n    this.totalValueToCurrentIndex = 0;\n    this.countAtThisValue = 0;\n    this.freshSubBucket = true;\n    this.currentIterationValue.reset();\n  }\n\n  /**\n   * Returns true if the iteration has more elements. (In other words, returns true if next would return an\n   * element rather than throwing an exception.)\n   *\n   * @return true if the iterator has more elements.\n   */\n  public hasNext(): boolean {\n    if (this.histogram.totalCount !== this.savedHistogramTotalRawCount) {\n      throw \"Concurrent Modification Exception\";\n    }\n    if (this.totalCountToCurrentIndex < this.arrayTotalCount) {\n      return true;\n    }\n    if (!this.reachedLastRecordedValue && this.arrayTotalCount > 0) {\n      this.percentileLevelToIterateTo = 100;\n      this.reachedLastRecordedValue = true;\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Returns the next element in the iteration.\n   *\n   * @return the {@link HistogramIterationValue} associated with the next element in the iteration.\n   */\n  public next(): HistogramIterationValue {\n    // Move through the sub buckets and buckets until we hit the next reporting level:\n    while (!this.exhaustedSubBuckets()) {\n      this.countAtThisValue = this.histogram.getCountAtIndex(this.currentIndex);\n      if (this.freshSubBucket) {\n        // Don't add unless we've incremented since last bucket...\n        this.totalCountToCurrentIndex += this.countAtThisValue;\n        this.totalValueToCurrentIndex +=\n          this.countAtThisValue *\n          this.histogram.highestEquivalentValue(this.currentValueAtIndex);\n        this.freshSubBucket = false;\n      }\n      if (this.reachedIterationLevel()) {\n        const valueIteratedTo = this.getValueIteratedTo();\n\n        //Object.assign(this.currentIterationValue, {\n        this.currentIterationValue.valueIteratedTo = valueIteratedTo;\n        this.currentIterationValue.valueIteratedFrom = this.prevValueIteratedTo;\n        this.currentIterationValue.countAtValueIteratedTo = this.countAtThisValue;\n        this.currentIterationValue.countAddedInThisIterationStep =\n          this.totalCountToCurrentIndex - this.totalCountToPrevIndex;\n        this.currentIterationValue.totalCountToThisValue = this.totalCountToCurrentIndex;\n        this.currentIterationValue.totalValueToThisValue = this.totalValueToCurrentIndex;\n        this.currentIterationValue.percentile =\n          (<f64>100 * <f64>this.totalCountToCurrentIndex) /\n          <f64>this.arrayTotalCount;\n        this.currentIterationValue.percentileLevelIteratedTo = this.getPercentileIteratedTo();\n        this.prevValueIteratedTo = valueIteratedTo;\n        this.totalCountToPrevIndex = this.totalCountToCurrentIndex;\n        this.incrementIterationLevel();\n        if (this.histogram.totalCount !== this.savedHistogramTotalRawCount) {\n          throw new Error(\"Concurrent Modification Exception\");\n        }\n        return this.currentIterationValue;\n      }\n      this.incrementSubBucket();\n    }\n    throw new Error(\"Index Out Of Bounds Exception\");\n  }\n\n  getPercentileIteratedTo(): f64 {\n    return this.percentileLevelToIterateTo;\n  }\n\n  getPercentileIteratedFrom(): f64 {\n    return this.percentileLevelToIterateFrom;\n  }\n\n  getValueIteratedTo(): u64 {\n    return this.histogram.highestEquivalentValue(this.currentValueAtIndex);\n  }\n\n  private exhaustedSubBuckets(): boolean {\n    return this.currentIndex >= this.histogram.countsArrayLength;\n  }\n\n  incrementSubBucket(): void {\n    this.freshSubBucket = true;\n    this.currentIndex++;\n    this.currentValueAtIndex = this.histogram.valueFromIndex(this.currentIndex);\n    this.nextValueAtIndex = this.histogram.valueFromIndex(\n      this.currentIndex + 1\n    );\n  }\n}\n\nexport default PercentileIterator;\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\n/**\n * Represents a value point iterated through in a Histogram, with associated stats.\n * <ul>\n * <li><b><code>valueIteratedTo</code></b> :<br> The actual value level that was iterated to by the iterator</li>\n * <li><b><code>prevValueIteratedTo</code></b> :<br> The actual value level that was iterated from by the iterator</li>\n * <li><b><code>countAtValueIteratedTo</code></b> :<br> The count of recorded values in the histogram that\n * exactly match this [lowestEquivalentValue(valueIteratedTo)...highestEquivalentValue(valueIteratedTo)] value\n * range.</li>\n * <li><b><code>countAddedInThisIterationStep</code></b> :<br> The count of recorded values in the histogram that\n * were added to the totalCountToThisValue (below) as a result on this iteration step. Since multiple iteration\n * steps may occur with overlapping equivalent value ranges, the count may be lower than the count found at\n * the value (e.g. multiple linear steps or percentile levels can occur within a single equivalent value range)</li>\n * <li><b><code>totalCountToThisValue</code></b> :<br> The total count of all recorded values in the histogram at\n * values equal or smaller than valueIteratedTo.</li>\n * <li><b><code>totalValueToThisValue</code></b> :<br> The sum of all recorded values in the histogram at values\n * equal or smaller than valueIteratedTo.</li>\n * <li><b><code>percentile</code></b> :<br> The percentile of recorded values in the histogram at values equal\n * or smaller than valueIteratedTo.</li>\n * <li><b><code>percentileLevelIteratedTo</code></b> :<br> The percentile level that the iterator returning this\n * HistogramIterationValue had iterated to. Generally, percentileLevelIteratedTo will be equal to or smaller than\n * percentile, but the same value point can contain multiple iteration levels for some iterators. E.g. a\n * PercentileIterator can stop multiple times in the exact same value point (if the count at that value covers a\n * range of multiple percentiles in the requested percentile iteration points).</li>\n * </ul>\n */\nclass HistogramIterationValue {\n  valueIteratedTo: u64;\n  valueIteratedFrom: u64;\n  countAtValueIteratedTo: u64;\n  countAddedInThisIterationStep: u64;\n  totalCountToThisValue: u64;\n  totalValueToThisValue: u64;\n  percentile: f64;\n  percentileLevelIteratedTo: f64;\n\n  constructor() {\n    this.reset();\n  }\n\n  reset(): void {\n    this.valueIteratedTo = 0;\n    this.valueIteratedFrom = 0;\n    this.countAtValueIteratedTo = 0;\n    this.countAddedInThisIterationStep = 0;\n    this.totalCountToThisValue = 0;\n    this.totalValueToThisValue = 0;\n    this.percentile = 0.0;\n    this.percentileLevelIteratedTo = 0.0;\n  }\n}\n\nexport default HistogramIterationValue;\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport Histogram from \"./Histogram\";\nimport HistogramIterationValue from \"./HistogramIterationValue\";\n\n/**\n * Used for iterating through all recorded histogram values using the finest granularity steps supported by the\n * underlying representation. The iteration steps through all non-zero recorded value counts, and terminates when\n * all recorded histogram values are exhausted.\n */\nclass RecordedValuesIterator<T, U> {\n  visitedIndex: i32;\n  histogram: Histogram<T, U>;\n  savedHistogramTotalRawCount: u64;\n  currentIndex: i32;\n  currentValueAtIndex: u64;\n  nextValueAtIndex: u64;\n  prevValueIteratedTo: u64;\n  totalCountToPrevIndex: u64;\n  totalCountToCurrentIndex: u64;\n  totalValueToCurrentIndex: u64;\n  arrayTotalCount: u64;\n  countAtThisValue: u64;\n\n  private freshSubBucket: boolean;\n\n  currentIterationValue: HistogramIterationValue = new HistogramIterationValue();\n\n  /**\n   * @param histogram The histogram this iterator will operate on\n   */\n  constructor(histogram: Histogram<T, U>) {\n    this.doReset(histogram);\n  }\n\n  /**\n   * Reset iterator for re-use in a fresh iteration over the same histogram data set.\n   */\n  public reset(): void {\n    this.doReset(this.histogram);\n  }\n\n  private doReset(histogram: Histogram<T, U>): void {\n    this.resetIterator(histogram);\n    this.visitedIndex = -1;\n  }\n\n  incrementIterationLevel(): void {\n    this.visitedIndex = this.currentIndex;\n  }\n\n  reachedIterationLevel(): bool {\n    const currentCount = this.histogram.getCountAtIndex(this.currentIndex);\n    return currentCount != 0 && this.visitedIndex !== this.currentIndex;\n  }\n\n  resetIterator(histogram: Histogram<T, U>): void {\n    this.histogram = histogram;\n    this.savedHistogramTotalRawCount = histogram.totalCount;\n    this.arrayTotalCount = histogram.totalCount;\n    this.currentIndex = 0;\n    this.currentValueAtIndex = 0;\n    this.nextValueAtIndex = 1 << histogram.unitMagnitude;\n    this.prevValueIteratedTo = 0;\n    this.totalCountToPrevIndex = 0;\n    this.totalCountToCurrentIndex = 0;\n    this.totalValueToCurrentIndex = 0;\n    this.countAtThisValue = 0;\n    this.freshSubBucket = true;\n    this.currentIterationValue.reset();\n  }\n\n  /**\n   * Returns true if the iteration has more elements. (In other words, returns true if next would return an\n   * element rather than throwing an exception.)\n   *\n   * @return true if the iterator has more elements.\n   */\n  public hasNext(): boolean {\n    if (this.histogram.totalCount !== this.savedHistogramTotalRawCount) {\n      throw \"Concurrent Modification Exception\";\n    }\n    return this.totalCountToCurrentIndex < this.arrayTotalCount;\n  }\n\n  /**\n   * Returns the next element in the iteration.\n   *\n   * @return the {@link HistogramIterationValue} associated with the next element in the iteration.\n   */\n  public next(): HistogramIterationValue {\n    // Move through the sub buckets and buckets until we hit the next reporting level:\n    while (!this.exhaustedSubBuckets()) {\n      this.countAtThisValue = this.histogram.getCountAtIndex(this.currentIndex);\n      if (this.freshSubBucket) {\n        // Don't add unless we've incremented since last bucket...\n        this.totalCountToCurrentIndex += this.countAtThisValue;\n        this.totalValueToCurrentIndex +=\n          this.countAtThisValue *\n          this.histogram.highestEquivalentValue(this.currentValueAtIndex);\n        this.freshSubBucket = false;\n      }\n      if (this.reachedIterationLevel()) {\n        const valueIteratedTo = this.getValueIteratedTo();\n\n        //Object.assign(this.currentIterationValue, {\n        this.currentIterationValue.valueIteratedTo = valueIteratedTo;\n        this.currentIterationValue.valueIteratedFrom = this.prevValueIteratedTo;\n        this.currentIterationValue.countAtValueIteratedTo = this.countAtThisValue;\n        this.currentIterationValue.countAddedInThisIterationStep =\n          this.totalCountToCurrentIndex - this.totalCountToPrevIndex;\n        this.currentIterationValue.totalCountToThisValue = this.totalCountToCurrentIndex;\n        this.currentIterationValue.totalValueToThisValue = this.totalValueToCurrentIndex;\n        this.currentIterationValue.percentile =\n          (<f64>100 * <f64>this.totalCountToCurrentIndex) /\n          <f64>this.arrayTotalCount;\n        this.currentIterationValue.percentileLevelIteratedTo = this.getPercentileIteratedTo();\n        this.prevValueIteratedTo = valueIteratedTo;\n        this.totalCountToPrevIndex = this.totalCountToCurrentIndex;\n        this.incrementIterationLevel();\n        if (this.histogram.totalCount !== this.savedHistogramTotalRawCount) {\n          throw new Error(\"Concurrent Modification Exception\");\n        }\n        return this.currentIterationValue;\n      }\n      this.incrementSubBucket();\n    }\n    throw new Error(\"Index Out Of Bounds Exception\");\n  }\n\n  getPercentileIteratedTo(): f64 {\n    return (\n      (<f64>100 * <f64>this.totalCountToCurrentIndex) /\n      <f64>this.arrayTotalCount\n    );\n  }\n\n  getPercentileIteratedFrom(): f64 {\n    return (\n      (<f64>100 * <f64>this.totalCountToPrevIndex) / <f64>this.arrayTotalCount\n    );\n  }\n\n  getValueIteratedTo(): u64 {\n    return this.histogram.highestEquivalentValue(this.currentValueAtIndex);\n  }\n\n  private exhaustedSubBuckets(): boolean {\n    return this.currentIndex >= this.histogram.countsArrayLength;\n  }\n\n  incrementSubBucket(): void {\n    this.freshSubBucket = true;\n    this.currentIndex++;\n    this.currentValueAtIndex = this.histogram.valueFromIndex(this.currentIndex);\n    this.nextValueAtIndex = this.histogram.valueFromIndex(\n      this.currentIndex + 1\n    );\n  }\n}\n\nexport default RecordedValuesIterator;\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\n/**\n * Mimic Java's ByteBufffer with big endian order\n */\nclass ByteBuffer {\n  position: i32;\n\n  data: Uint8Array;\n\n  int64ArrayForConvert: Uint64Array;\n  int32ArrayForConvert: Uint32Array;\n  int8ArrayForConvertInt32: Uint8Array;\n  int8ArrayForConvertInt64: Uint8Array;\n\n  static allocate(size: i32 = 16): ByteBuffer {\n    return new ByteBuffer(new Uint8Array(size));\n  }\n\n  constructor(data: Uint8Array) {\n    this.position = 0;\n    this.data = data;\n    this.int64ArrayForConvert = new Uint64Array(1);\n    this.int32ArrayForConvert = new Uint32Array(1);\n    this.int8ArrayForConvertInt32 = Uint8Array.wrap(\n      this.int32ArrayForConvert.buffer\n    );\n    this.int8ArrayForConvertInt64 = Uint8Array.wrap(\n      this.int64ArrayForConvert.buffer\n    );\n  }\n\n  put(value: u8): void {\n    if (this.position === this.data.length) {\n      const oldArray = this.data;\n      this.data = new Uint8Array(this.data.length << 1);\n      this.data.set(oldArray);\n    }\n    unchecked((this.data[this.position] = value));\n    this.position++;\n  }\n\n  putInt32(value: u32): void {\n    if (this.data.length - this.position < 4) {\n      const oldArray = this.data;\n      this.data = new Uint8Array((this.data.length << 1) + 4);\n      this.data.set(oldArray);\n    }\n    unchecked((this.int32ArrayForConvert[0] = value));\n    this.data.set(this.int8ArrayForConvertInt32.reverse(), this.position);\n    this.position += 4;\n  }\n\n  putInt64(value: u64): void {\n    if (this.data.length - this.position < 8) {\n      const oldArray = this.data;\n      this.data = new Uint8Array((this.data.length << 1) + 8);\n      this.data.set(oldArray);\n    }\n    unchecked((this.int64ArrayForConvert[0] = value));\n    this.data.set(this.int8ArrayForConvertInt64.reverse(), this.position);\n    this.position += 8;\n  }\n\n  putArray(array: Uint8Array): void {\n    if (this.data.length - this.position < array.byteLength) {\n      const oldArray = this.data;\n      this.data = new Uint8Array(this.position + array.byteLength);\n      this.data.set(oldArray);\n    }\n    this.data.set(array, this.position);\n    this.position += array.byteLength;\n  }\n\n  get(): u8 {\n    const value = unchecked(this.data[this.position]);\n    this.position++;\n    return value;\n  }\n\n  getInt32(): u32 {\n    this.int8ArrayForConvertInt32.set(\n      this.data.slice(this.position, this.position + 4).reverse()\n    );\n    const value = unchecked(this.int32ArrayForConvert[0]);\n    this.position += 4;\n    return value;\n  }\n\n  getInt64(): u64 {\n    this.int8ArrayForConvertInt64.set(\n      this.data.slice(this.position, this.position + 8).reverse()\n    );\n    const value = unchecked(this.int64ArrayForConvert[0]);\n    this.position += 8;\n    return value;\n  }\n\n  resetPosition(): void {\n    this.position = 0;\n  }\n}\n\nexport default ByteBuffer;\n","/*\n * This is a AssemblyScript port of the original Java version, which was written by\n * Gil Tene as described in\n * https://github.com/HdrHistogram/HdrHistogram\n * and released to the public domain, as explained at\n * http://creativecommons.org/publicdomain/zero/1.0/\n */\n\nimport ByteBuffer from \"./ByteBuffer\";\n\n/**\n * This class provides encoding and decoding methods for writing and reading\n * ZigZag-encoded LEB128-64b9B-variant (Little Endian Base 128) values to/from a\n * {@link ByteBuffer}. LEB128's variable length encoding provides for using a\n * smaller nuber of bytes for smaller values, and the use of ZigZag encoding\n * allows small (closer to zero) negative values to use fewer bytes. Details\n * on both LEB128 and ZigZag can be readily found elsewhere.\n *\n * The LEB128-64b9B-variant encoding used here diverges from the \"original\"\n * LEB128 as it extends to 64 bit values: In the original LEB128, a 64 bit\n * value can take up to 10 bytes in the stream, where this variant's encoding\n * of a 64 bit values will max out at 9 bytes.\n *\n * As such, this encoder/decoder should NOT be used for encoding or decoding\n * \"standard\" LEB128 formats (e.g. Google Protocol Buffers).\n */\nclass ZigZagEncoding {\n  /**\n   * Writes a 64b value to the given buffer in LEB128 ZigZag encoded format\n   * (negative numbers not supported)\n   * @param buffer the buffer to write to\n   * @param value  the value to write to the buffer\n   */\n  static encode(buffer: ByteBuffer, value: i64): void {\n    value = (value << 1) ^ (value >> 63);\n    if (value >>> 7 === 0) {\n      buffer.put(<u8>value);\n    } else {\n      buffer.put(<u8>((value & 0x7f) | 0x80));\n      if (value >>> 14 === 0) {\n        buffer.put(<u8>(value >>> 7));\n      } else {\n        buffer.put(<u8>((value >>> 7) | 0x80));\n        if (value >>> 21 === 0) {\n          buffer.put(<u8>(value >>> 14));\n        } else {\n          buffer.put(<u8>((value >>> 14) | 0x80));\n          if (value >>> 28 === 0) {\n            buffer.put(<u8>(value >>> 21));\n          } else {\n            buffer.put(<u8>((value >>> 21) | 0x80));\n            if (value >>> 35 === 0) {\n              buffer.put(<u8>(value >>> 28));\n            } else {\n              buffer.put(<u8>((value >>> 28) | 0x80));\n              if (value >>> 42 === 0) {\n                buffer.put(<u8>(value >>> 35));\n              } else {\n                buffer.put(<u8>((value >>> 35) | 0x80));\n                if (value >>> 49 === 0) {\n                  buffer.put(<u8>(value >>> 42));\n                } else {\n                  buffer.put(<u8>((value >>> 42) | 0x80));\n                  if (value >>> 56 === 0) {\n                    buffer.put(<u8>(value >>> 49));\n                  } else {\n                    buffer.put(<u8>((value >>> 49) | 0x80));\n                    buffer.put(<u8>(value >>> 56));\n                  }\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Read an LEB128-64b9B ZigZag encoded long value from the given buffer\n   * (negative numbers not supported)\n   * @param buffer the buffer to read from\n   * @return the value read from the buffer\n   */\n  static decode(buffer: ByteBuffer): i64 {\n    let v = <i64>buffer.get();\n    let value: i64 = (<i64>v) & (<i64>0x7f);\n    if ((v & 0x80) != 0) {\n      v = buffer.get();\n      value |= (v & 0x7f) << 7;\n      if ((v & 0x80) != 0) {\n        v = buffer.get();\n        value |= (v & 0x7f) << 14;\n        if ((v & 0x80) != 0) {\n          v = buffer.get();\n          value |= (v & 0x7f) << 21;\n          if ((v & 0x80) != 0) {\n            v = buffer.get();\n            value |= (v & 0x7f) << 28;\n            if ((v & 0x80) != 0) {\n              v = buffer.get();\n              value |= (v & 0x7f) << 35;\n              if ((v & 0x80) != 0) {\n                v = buffer.get();\n                value |= (v & 0x7f) << 42;\n                if ((v & 0x80) != 0) {\n                  v = buffer.get();\n                  value |= (v & 0x7f) << 49;\n                  if ((v & 0x80) != 0) {\n                    v = buffer.get();\n                    value |= v << 56;\n                  }\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n    value = (value >>> 1) ^ -(value & 1);\n    return value;\n  }\n}\n\nexport default ZigZagEncoding;\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { BLOCK, BLOCK_OVERHEAD } from \"./rt/common\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n  var ptr = __rtti_base;\n  if (id > load<u32>(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n  return changetype<Typeinfo>(ptr + sizeof<u32>() + id * offsetof<Typeinfo>()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __instanceof(ref: usize, superId: u32): bool { // keyword\n  var id = changetype<BLOCK>(ref - BLOCK_OVERHEAD).rtId;\n  var ptr = __rtti_base;\n  if (id <= load<u32>(ptr)) {\n    do if (id == superId) return true;\n    while (id = changetype<Typeinfo>(ptr + sizeof<u32>() + id * offsetof<Typeinfo>()).base);\n  }\n  return false;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __allocBuffer(size: usize, id: u32, data: usize = 0): usize {\n  var buffer = __alloc(size, id);\n  if (data) memory.copy(buffer, data, size);\n  return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __allocArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n  var array = __alloc(offsetof<i32[]>(), id);\n  var bufferSize = <usize>length << alignLog2;\n  var buffer = __allocBuffer(bufferSize, idof<ArrayBuffer>(), data);\n  store<usize>(array, __retain(buffer), offsetof<ArrayBufferView>(\"buffer\"));\n  store<usize>(array, buffer, offsetof<ArrayBufferView>(\"dataStart\"));\n  store<i32>(array, bufferSize, offsetof<ArrayBufferView>(\"byteLength\"));\n  store<i32>(array, length, offsetof<i32[]>(\"length_\"));\n  return array;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// @builtin @unsafe\n// export declare function __alloc(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ref: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ref: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __retain(ref: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __release(ref: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ref: usize, cookie: u32): void;\n","/// <reference path=\"./rt/index.d.ts\" />\n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureSize(array: usize, minSize: usize, alignLog2: u32): void {\n  // depends on the fact that Arrays mimic ArrayBufferView\n  var oldCapacity = changetype<ArrayBufferView>(array).byteLength;\n  if (minSize > <usize>oldCapacity >>> alignLog2) {\n    if (minSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n    let oldData = changetype<usize>(changetype<ArrayBufferView>(array).buffer);\n    let newCapacity = minSize << alignLog2;\n    let newData = __realloc(oldData, newCapacity); // keeps RC\n    memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n    if (newData !== oldData) { // oldData has been free'd\n      store<usize>(array, newData, offsetof<ArrayBufferView>(\"buffer\"));\n      store<usize>(array, newData, offsetof<ArrayBufferView>(\"dataStart\"));\n    }\n    store<u32>(array, newCapacity, offsetof<ArrayBufferView>(\"byteLength\"));\n  }\n}\n\nexport class Array<T> {\n  [key: number]: T;\n\n  // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n  // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n  // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n  // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n  private buffer: ArrayBuffer;\n  private dataStart: usize;\n  private byteLength: i32;\n\n  // Also note that Array<T> with non-nullable T must guard against uninitialized null values\n  // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n  // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n  private length_: i32;\n\n  static isArray<U>(value: U): bool {\n    return isReference<U>() ? builtin_isArray(value) && value !== null : false;\n  }\n\n  static create<T>(capacity: i32 = 0): Array<T> {\n    WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n    var array = new Array<T>(capacity);\n    array.length = 0;\n    return array;\n  }\n\n  constructor(length: i32 = 0) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new RangeError(E_INVALIDLENGTH);\n    var bufferSize = <usize>length << alignof<T>();\n    var buffer = __alloc(bufferSize, idof<ArrayBuffer>());\n    memory.fill(buffer, 0, bufferSize);\n    this.buffer = changetype<ArrayBuffer>(buffer); // retains\n    this.dataStart = buffer;\n    this.byteLength = <i32>bufferSize;\n    this.length_ = length;\n  }\n\n  get length(): i32 {\n    return this.length_;\n  }\n\n  set length(newLength: i32) {\n    var oldLength = this.length_;\n    if (isManaged<T>()) {\n      if (oldLength > newLength) { // release no longer used refs\n        let dataStart = this.dataStart;\n        let cur = dataStart + (<usize>newLength << alignof<T>());\n        let end = dataStart + (<usize>oldLength << alignof<T>());\n        do __release(load<usize>(cur));\n        while ((cur += sizeof<T>()) < end);\n      } else {\n        ensureSize(changetype<usize>(this), newLength, alignof<T>());\n      }\n    } else {\n      ensureSize(changetype<usize>(this), newLength, alignof<T>());\n    }\n    this.length_ = newLength;\n  }\n\n  every(fn: (value: T, index: i32, array: Array<T>) => bool): bool {\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      if (!fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return false;\n    }\n    return true;\n  }\n\n  findIndex(predicate: (value: T, index: i32, array: Array<T>) => bool): i32 {\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      if (predicate(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return index;\n    }\n    return -1;\n  }\n\n  @operator(\"[]\") private __get(index: i32): T {\n    if (<u32>index >= <u32>this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n    var value = this.__uget(index);\n    if (isReference<T>()) {\n      if (!isNullable<T>()) {\n        if (!changetype<usize>(value)) throw new Error(E_HOLEYARRAY);\n      }\n    }\n    return value;\n  }\n\n  @unsafe @operator(\"{}\") private __uget(index: i32): T {\n    return load<T>(this.dataStart + (<usize>index << alignof<T>()));\n  }\n\n  @operator(\"[]=\") private __set(index: i32, value: T): void {\n    if (<u32>index >= <u32>this.length_) {\n      if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n      ensureSize(changetype<usize>(this), index + 1, alignof<T>());\n      this.length_ = index + 1;\n    }\n    this.__uset(index, value);\n  }\n\n  @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n    if (isManaged<T>()) {\n      let offset = this.dataStart + (<usize>index << alignof<T>());\n      let oldRef = load<usize>(offset);\n      if (changetype<usize>(value) != oldRef) {\n        store<usize>(offset, __retain(changetype<usize>(value)));\n        __release(oldRef);\n      }\n    } else {\n      store<T>(this.dataStart + (<usize>index << alignof<T>()), value);\n    }\n  }\n\n  fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): this {\n    var dataStart = this.dataStart;\n    var length = this.length_;\n    start = start < 0 ? max(length + start, 0) : min(start, length);\n    end   = end   < 0 ? max(length + end,   0) : min(end,   length);\n    if (isManaged<T>()) {\n      for (; start < end; ++start) {\n        let oldRef: usize = load<usize>(dataStart + (<usize>start << alignof<T>()));\n        if (changetype<usize>(value) != oldRef) {\n          store<usize>(dataStart + (<usize>start << alignof<T>()), __retain(changetype<usize>(value)));\n          __release(oldRef);\n        }\n      }\n    } else if (sizeof<T>() == 1) {\n      if (start < end) {\n        memory.fill(\n          dataStart + <usize>start,\n          u8(value),\n          <usize>(end - start)\n        );\n      }\n    } else {\n      for (; start < end; ++start) {\n        store<T>(dataStart + (<usize>start << alignof<T>()), value);\n      }\n    }\n    return this;\n  }\n\n  includes(value: T, fromIndex: i32 = 0): bool {\n    if (isFloat<T>()) {\n      let length = this.length_;\n      if (length == 0 || fromIndex >= length) return false;\n      if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n      let dataStart = this.dataStart;\n      while (fromIndex < length) {\n        let elem = load<T>(dataStart + (<usize>fromIndex << alignof<T>()));\n        // @ts-ignore\n        if (elem == value || isNaN(elem) & isNaN(value)) return true;\n        ++fromIndex;\n      }\n      return false;\n    } else {\n      return this.indexOf(value, fromIndex) >= 0;\n    }\n  }\n\n  indexOf(value: T, fromIndex: i32 = 0): i32 {\n    var length = this.length_;\n    if (length == 0 || fromIndex >= length) return -1;\n    if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n    var dataStart = this.dataStart;\n    while (fromIndex < length) {\n      if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;\n      ++fromIndex;\n    }\n    return -1;\n  }\n\n  lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n    var length = this.length_;\n    if (length == 0) return -1;\n    if (fromIndex < 0) fromIndex = length + fromIndex;\n    else if (fromIndex >= length) fromIndex = length - 1;\n    var dataStart = this.dataStart;\n    while (fromIndex >= 0) {\n      if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;\n      --fromIndex;\n    }\n    return -1;\n  }\n\n  push(value: T): i32 {\n    var length = this.length_;\n    var newLength = length + 1;\n    ensureSize(changetype<usize>(this), newLength, alignof<T>());\n    if (isManaged<T>()) {\n      store<usize>(this.dataStart + (<usize>length << alignof<T>()), __retain(changetype<usize>(value)));\n    } else {\n      store<T>(this.dataStart + (<usize>length << alignof<T>()), value);\n    }\n    this.length_ = newLength;\n    return newLength;\n  }\n\n  concat(other: Array<T>): Array<T> {\n    var thisLen = this.length_;\n    var otherLen = select(0, other.length_, other === null);\n    var outLen = thisLen + otherLen;\n    if (<u32>outLen > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new Error(E_INVALIDLENGTH);\n    var out = changetype<Array<T>>(__allocArray(outLen, alignof<T>(), idof<Array<T>>())); // retains\n    var outStart = out.dataStart;\n    var thisSize = <usize>thisLen << alignof<T>();\n    if (isManaged<T>()) {\n      let thisStart = this.dataStart;\n      for (let offset: usize = 0; offset < thisSize; offset += sizeof<T>()) {\n        let ref = load<usize>(thisStart + offset);\n        store<usize>(outStart + offset, __retain(ref));\n      }\n      outStart += thisSize;\n      let otherStart = other.dataStart;\n      let otherSize = <usize>otherLen << alignof<T>();\n      for (let offset: usize = 0; offset < otherSize; offset += sizeof<T>()) {\n        let ref = load<usize>(otherStart + offset);\n        store<usize>(outStart + offset, __retain(ref));\n      }\n    } else {\n      memory.copy(outStart, this.dataStart, thisSize);\n      memory.copy(outStart + thisSize, other.dataStart, <usize>otherLen << alignof<T>());\n    }\n    return out;\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): this {\n    var dataStart = this.dataStart;\n    var len = this.length_;\n\n    end = min<i32>(end, len);\n\n    var to    = target < 0 ? max(len + target, 0) : min(target, len);\n    var from  = start < 0 ? max(len + start, 0) : min(start, len);\n    var last  = end < 0 ? max(len + end, 0) : min(end, len);\n    var count = min(last - from, len - to);\n\n    if (isManaged<T>()) {\n      if (from < to && to < (from + count)) { // right to left\n        from += count - 1;\n        to   += count - 1;\n        while (count) {\n          let oldRef: usize = load<usize>(dataStart + (<usize>to << alignof<T>()));\n          let newRef: usize = load<usize>(dataStart + (<usize>from << alignof<T>()));\n          if (newRef != oldRef) {\n            store<usize>(dataStart + (<usize>to << alignof<T>()), __retain(newRef));\n            __release(oldRef);\n          }\n          --from, --to, --count;\n        }\n      } else { // left to right\n        while (count) {\n          let oldRef: usize = load<usize>(dataStart + (<usize>to << alignof<T>()));\n          let newRef: usize = load<usize>(dataStart + (<usize>from << alignof<T>()));\n          if (newRef != oldRef) {\n            store<usize>(dataStart + (<usize>to << alignof<T>()), __retain(newRef));\n            __release(oldRef);\n          }\n          ++from, ++to, --count;\n        }\n      }\n    } else {\n      memory.copy( // is memmove\n        dataStart + (<usize>to << alignof<T>()),\n        dataStart + (<usize>from << alignof<T>()),\n        <usize>count << alignof<T>()\n      );\n    }\n    return this;\n  }\n\n  pop(): T {\n    var length = this.length_;\n    if (length < 1) throw new RangeError(E_EMPTYARRAY);\n    var element = load<T>(this.dataStart + (<usize>(--length) << alignof<T>()));\n    this.length_ = length;\n    return element; // no need to retain -> is moved\n  }\n\n  forEach(fn: (value: T, index: i32, array: Array<T>) => void): void {\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);\n    }\n  }\n\n  map<U>(fn: (value: T, index: i32, array: Array<T>) => U): Array<U> {\n    var length = this.length_;\n    var out = changetype<Array<U>>(__allocArray(length, alignof<U>(), idof<Array<U>>())); // retains\n    var outStart = out.dataStart;\n    for (let index = 0; index < min(length, this.length_); ++index) {\n      let result = fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this); // retains\n      if (isManaged<U>()) {\n        store<usize>(outStart + (<usize>index << alignof<U>()), __retain(changetype<usize>(result)));\n      } else {\n        store<U>(outStart + (<usize>index << alignof<U>()), result);\n      }\n      // releases result\n    }\n    return out;\n  }\n\n  filter(fn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {\n    var result = changetype<Array<T>>(__allocArray(0, alignof<T>(), idof<Array<T>>())); // retains\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      let value = load<T>(this.dataStart + (<usize>index << alignof<T>()));\n      if (fn(value, index, this)) result.push(value);\n    }\n    return result;\n  }\n\n  reduce<U>(\n    fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,\n    initialValue: U\n  ): U {\n    var accum = initialValue;\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      accum = fn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);\n    }\n    return accum;\n  }\n\n  reduceRight<U>(\n    fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,\n    initialValue: U\n  ): U {\n    var accum = initialValue;\n    for (let index = this.length_ - 1; index >= 0; --index) {\n      accum = fn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);\n    }\n    return accum;\n  }\n\n  shift(): T {\n    var length = this.length_;\n    if (length < 1) throw new RangeError(E_EMPTYARRAY);\n    var base = this.dataStart;\n    var element = load<T>(base);\n    var lastIndex = length - 1;\n    memory.copy(\n      base,\n      base + sizeof<T>(),\n      <usize>lastIndex << alignof<T>()\n    );\n    store<T>(base + (<usize>lastIndex << alignof<T>()), changetype<T>(0));\n    this.length_ = lastIndex;\n    return element; // no need to retain -> is moved\n  }\n\n  some(fn: (value: T, index: i32, array: Array<T>) => bool): bool {\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      if (fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return true;\n    }\n    return false;\n  }\n\n  unshift(value: T): i32 {\n    var newLength = this.length_ + 1;\n    ensureSize(changetype<usize>(this), newLength, alignof<T>());\n    var dataStart = this.dataStart;\n    memory.copy(\n      dataStart + sizeof<T>(),\n      dataStart,\n      <usize>(newLength - 1) << alignof<T>()\n    );\n    if (isManaged<T>()) {\n      store<usize>(dataStart, __retain(changetype<usize>(value)));\n    } else {\n      store<T>(dataStart, value);\n    }\n    this.length_ = newLength;\n    return newLength;\n  }\n\n  slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array<T> {\n    var length = this.length_;\n    start = start < 0 ? max(start + length, 0) : min(start, length);\n    end   = end   < 0 ? max(end   + length, 0) : min(end  , length);\n    length = max(end - start, 0);\n    var slice = changetype<Array<T>>(__allocArray(length, alignof<T>(), idof<Array<T>>())); // retains\n    var sliceBase = slice.dataStart;\n    var thisBase = this.dataStart + (<usize>start << alignof<T>());\n    if (isManaged<T>()) {\n      let off = <usize>0;\n      let end = <usize>length << alignof<usize>();\n      while (off < end) {\n        let ref = load<usize>(thisBase + off);\n        store<usize>(sliceBase + off, __retain(ref));\n        off += sizeof<usize>();\n      }\n    } else {\n      memory.copy(sliceBase, thisBase, length << alignof<T>());\n    }\n    return slice;\n  }\n\n  splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array<T> {\n    var length  = this.length_;\n    start       = start < 0 ? max<i32>(length + start, 0) : min<i32>(start, length);\n    deleteCount = max<i32>(min<i32>(deleteCount, length - start), 0);\n    var result = changetype<Array<T>>(__allocArray(deleteCount, alignof<T>(), idof<Array<T>>())); // retains\n    var resultStart = result.dataStart;\n    var thisStart = this.dataStart;\n    var thisBase  = thisStart + (<usize>start << alignof<T>());\n    // no need to retain -> is moved\n    memory.copy(\n      resultStart,\n      thisBase,\n      <usize>deleteCount << alignof<T>()\n    );\n    var offset = start + deleteCount;\n    if (length != offset) {\n      memory.copy(\n        thisBase,\n        thisStart + (<usize>offset << alignof<T>()),\n        <usize>(length - offset) << alignof<T>()\n      );\n    }\n    this.length_ = length - deleteCount;\n    return result;\n  }\n\n  reverse(): Array<T> {\n    var length = this.length_;\n    if (length) {\n      let front = this.dataStart;\n      let back = this.dataStart + (<usize>(length - 1) << alignof<T>());\n      while (front < back) {\n        let temp = load<T>(front);\n        store<T>(front, load<T>(back));\n        store<T>(back, temp);\n        front += sizeof<T>();\n        back -= sizeof<T>();\n      }\n    }\n    return this;\n  }\n\n  sort(comparator: (a: T, b: T) => i32 = COMPARATOR<T>()): this {\n    var length = this.length_;\n    if (length <= 1) return this;\n    var base = this.dataStart;\n    if (length == 2) {\n      let a: T = load<T>(base, sizeof<T>()); // a = arr[1]\n      let b: T = load<T>(base); // b = arr[0]\n      if (comparator(a, b) < 0) {\n        store<T>(base, b, sizeof<T>()); // arr[1] = b;\n        store<T>(base, a); // arr[0] = a;\n      }\n      return this;\n    }\n    SORT<T>(base, length, comparator);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    var dataStart = this.dataStart;\n    var length = this.length_;\n    if (isBoolean<T>())   return joinBooleanArray(dataStart, length, separator);\n    if (isInteger<T>())   return joinIntegerArray<T>(dataStart, length, separator);\n    if (isFloat<T>())     return joinFloatArray<T>(dataStart, length, separator);\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (isString<T>())  return joinStringArray(dataStart, length, separator);\n    }\n    // For rest objects and arrays use general join routine\n    if (isReference<T>()) return joinReferenceArray<T>(dataStart, length, separator);\n    ERROR(\"unspported element type\");\n    return <string>unreachable();\n  }\n\n  flat(): T {\n    if (!isArray<T>()) {\n      ERROR(\"Cannot call flat() on Array<T> where T is not an Array.\");\n    }\n    // Get the length and data start values\n    var length = this.length_;\n    var selfDataStart = this.dataStart;\n\n    // calculate the end size with an initial pass\n    var size = 0;\n    for (let i = 0; i < length; i++) {\n      let child = load<usize>(selfDataStart + (i << alignof<T>()));\n      size += child == 0 ? 0 : load<i32>(child, offsetof<T>(\"length_\"));\n    }\n\n    // calculate the byteLength of the resulting backing ArrayBuffer\n    var byteLength = <usize>size << usize(alignof<valueof<T>>());\n    var dataStart = __alloc(byteLength, idof<ArrayBuffer>());\n\n    // create the return value and initialize it\n    var result = __alloc(offsetof<T>(), idof<T>());\n    store<i32>(result, size, offsetof<T>(\"length_\"));\n\n    // byteLength, dataStart, and buffer are all readonly\n    store<i32>(result, byteLength, offsetof<T>(\"byteLength\"));\n    store<usize>(result, dataStart, offsetof<T>(\"dataStart\"));\n    store<usize>(result, __retain(dataStart), offsetof<T>(\"buffer\"));\n\n    // set the elements\n    var resultOffset: usize = 0;\n    for (let i = 0; i < length; i++) { // for each child\n      let child = load<usize>(selfDataStart + (<usize>i << alignof<T>()));\n\n      // ignore null arrays\n      if (child == 0) continue;\n\n      // copy the underlying buffer data to the result buffer\n      let childDataLength = load<i32>(child, offsetof<T>(\"byteLength\"));\n      memory.copy(\n        dataStart + resultOffset,\n        load<usize>(child, offsetof<T>(\"dataStart\")),\n        <usize>childDataLength\n      );\n\n      // advance the result length\n      resultOffset += childDataLength;\n    }\n\n    // if the `valueof<T>` type is managed, we must call __retain() on each reference\n    if (isManaged<valueof<T>>()) {\n      for (let i = 0; i < size; i++) {\n        __retain(load<usize>(dataStart + (<usize>i << usize(alignof<valueof<T>>()))));\n      }\n    }\n\n    return changetype<T>(result);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  // RT integration\n\n  @unsafe private __visit_impl(cookie: u32): void {\n    if (isManaged<T>()) {\n      let cur = this.dataStart;\n      let end = cur + (<usize>this.length_ << alignof<T>());\n      while (cur < end) {\n        let val = load<usize>(cur);\n        if (val) __visit(val, cookie);\n        cur += sizeof<usize>();\n      }\n    }\n    __visit(changetype<usize>(this.buffer), cookie);\n  }\n}\n"]}