srsly

2025-04-27 07:52:14 +00:00 · 2019-03-14 05:11:03 +01:00 · 2019-03-14 05:11:03 +01:00 · a5e14a0eaa
commit a5e14a0eaa
parent 6163a73ab5
24 changed files with 739 additions and 102 deletions
--- a/std/assembly/allocator/arena.ts
+++ b/std/assembly/allocator/arena.ts
@ -1,9 +1,13 @@
 import { HEAP_BASE, memory } from "../memory";
 import { AL_MASK, MAX_SIZE_32 } from "../util/allocator";
 // @ts-ignore: decorator
@lazy var startOffset: usize = (HEAP_BASE + AL_MASK) & ~AL_MASK;
 // @ts-ignore: decorator
@lazy var offset: usize = startOffset;
 // @ts-ignore: decorator
@unsafe @global function __memory_allocate(size: usize): usize {
  if (size > MAX_SIZE_32) unreachable();
  var ptr = offset;
@ -22,9 +26,11 @@ import { AL_MASK, MAX_SIZE_32 } from "../util/allocator";
  return ptr;
 }
 // @ts-ignore: decorator
@unsafe @global function __memory_free(ptr: usize): void {
 }
 // @ts-ignore: decorator
@unsafe @global function __memory_reset(): void {
  offset = startOffset;
 }
--- a/std/assembly/allocator/emscripten.ts
+++ b/std/assembly/allocator/emscripten.ts
@ -1,10 +1,15 @@
 // @ts-ignore: decorator
@unsafe declare function _malloc(size: usize): usize;
 // @ts-ignore: decorator
@unsafe declare function _free(ptr: usize): void;
 // @ts-ignore: decorator
@unsafe @global function __memory_allocate(size: usize): usize {
  return _malloc(size);
 }
 // @ts-ignore: decorator
@unsafe @global function __memory_free(ptr: usize): void {
  _free(ptr);
 }
--- a/std/assembly/allocator/system.ts
+++ b/std/assembly/allocator/system.ts
@ -1,10 +1,15 @@
 // @ts-ignore: decorator
@unsafe declare function malloc(size: usize): usize;
 // @ts-ignore: decorator
@unsafe declare function free(ptr: usize): void;
 // @ts-ignore: decorator
@unsafe @global function __memory_allocate(size: usize): usize {
  return malloc(size);
 }
 // @ts-ignore: decorator
@unsafe @global function __memory_free(ptr: usize): void {
  free(ptr);
 }
--- a/std/assembly/allocator/tlsf.ts
+++ b/std/assembly/allocator/tlsf.ts
@ -44,8 +44,7 @@ const LEFT_FREE: usize = 1 << 1;
 const TAGS: usize = FREE | LEFT_FREE;
 /** Block structure. */
-@unmanaged
+@unmanaged class Block {
 class Block {
  /** Info field holding this block's size and tags. */
  info: usize;
@ -110,8 +109,7 @@ class Block {
 assert((1 << SL_BITS) <= 32); // second level must fit into 32 bits
 /** Root structure. */
-@unmanaged
+@unmanaged class Root {
 class Root {
  /** First level bitmap. */
  flMap: usize = 0;
@ -406,15 +404,17 @@ class Root {
 }
 /** Determines the first (LSB to MSB) set bit's index of a word. */
-function ffs<T>(word: T): T {
+function ffs<T extends number>(word: T): T {
  assert(word != 0); // word cannot be 0
  return ctz<T>(word);  // differs from ffs only for 0
 }
 /** Determines the last (LSB to MSB) set bit's index of a word. */
-function fls<T>(word: T): T {
+function fls<T extends number>(word: T): T {
  assert(word != 0); // word cannot be 0
  // @ts-ignore: type
  const inv: T = (sizeof<T>() << 3) - 1;
  // @ts-ignore: type
  return inv - clz<T>(word);
 }
@ -422,6 +422,7 @@ function fls<T>(word: T): T {
 var ROOT: Root = changetype<Root>(0);
 /** Allocates a chunk of memory. */
 // @ts-ignore: decorator
@unsafe @global function __memory_allocate(size: usize): usize {
  // initialize if necessary
  var root = ROOT;
@ -470,6 +471,7 @@ var ROOT: Root = changetype<Root>(0);
 }
 /** Frees the chunk of memory at the specified address. */
 // @ts-ignore
@unsafe @global function __memory_free(data: usize): void {
  if (data) {
    let root = ROOT;
--- a/std/assembly/array.ts
+++ b/std/assembly/array.ts
@ -95,6 +95,7 @@ export class Array<T> extends ArrayBufferView {
      if (start < end) {
        memory.fill(
          dataStart + <usize>start,
          // @ts-ignore: cast
          <u8>value,
          <usize>(end - start)
        );
@ -268,6 +269,7 @@ export class Array<T> extends ArrayBufferView {
      base + sizeof<T>(),
      <usize>lastIndex << alignof<T>()
    );
    // @ts-ignore: cast
    store<T>(base + (<usize>lastIndex << alignof<T>()), <T>null);
    this.length_ = lastIndex;
    return element;
@ -375,6 +377,7 @@ export class Array<T> extends ArrayBufferView {
  join(separator: string = ","): string {
    if (isInteger<T>()) {
      // @ts-ignore: type
      if (value instanceof bool) return this.join_bool(separator);
      return this.join_int(separator);
    }
@ -400,6 +403,7 @@ export class Array<T> extends ArrayBufferView {
    var value: bool;
    for (let i = 0; i < lastIndex; ++i) {
      value = load<bool>(dataStart + i);
      // @ts-ignore: cast
      valueLen = 4 + <i32>(!value);
      memory.copy(
        result + (<usize>offset << 1),
@ -417,6 +421,7 @@ export class Array<T> extends ArrayBufferView {
      }
    }
    value = load<bool>(dataStart + <usize>lastIndex);
    // @ts-ignore: cast
    valueLen = 4 + <i32>(!value);
    memory.copy(
      result + (<usize>offset << 1),
@ -440,6 +445,7 @@ export class Array<T> extends ArrayBufferView {
    if (!lastIndex) return changetype<string>(itoa<T>(load<T>(dataStart)));
    var sepLen = separator.length;
    // @ts-ignore: cast
    const valueLen = (sizeof<T>() <= 4 ? 10 : 20) + <i32>isSigned<T>();
    var estLen = (valueLen + sepLen) * lastIndex + valueLen;
    var result = runtime.alloc(estLen << 1);
@ -471,6 +477,7 @@ export class Array<T> extends ArrayBufferView {
    var lastIndex = this.length_ - 1;
    if (lastIndex < 0) return "";
    var dataStart = this.dataStart;
    // @ts-ignore: type
    if (!lastIndex) return changetype<string>(dtoa(load<T>(dataStart)));
    const valueLen = MAX_DOUBLE_LENGTH;
@ -481,6 +488,7 @@ export class Array<T> extends ArrayBufferView {
    var value: T;
    for (let i = 0; i < lastIndex; ++i) {
      value = load<T>(dataStart + (<usize>i << alignof<T>()));
      // @ts-ignore: type
      offset += dtoa_stream(result, offset, value);
      if (sepLen) {
        memory.copy(
@ -492,6 +500,7 @@ export class Array<T> extends ArrayBufferView {
      }
    }
    value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));
    // @ts-ignore: type
    offset += dtoa_stream(result, offset, value);
    if (estLen > offset) {
      let trimmed = changetype<string>(result).substring(0, offset);
@ -557,14 +566,17 @@ export class Array<T> extends ArrayBufferView {
    var value: T;
    if (!lastIndex) {
      value = load<T>(base);
      // @ts-ignore: type
      return value ? value.join(separator) : "";
    }
    for (let i = 0; i < lastIndex; ++i) {
      value = load<T>(base + (<usize>i << alignof<T>()));
      // @ts-ignore: type
      if (value) result += value.join(separator);
      if (sepLen) result += separator;
    }
    value = load<T>(base + (<usize>lastIndex << alignof<T>()));
    // @ts-ignore: type
    if (value) result += value.join(separator);
    return result; // registered by concatenation (FIXME: lots of garbage)
  }
--- a/std/assembly/builtins.ts
+++ b/std/assembly/builtins.ts
@ -1,501 +1,898 @@
-/* tslint:disable */
+// @ts-ignore: decorator
@builtin @inline export const NaN: f64 = 0 / 0;
 // @ts-ignore: decorator
@builtin @inline export const Infinity: f64 = 1 / 0;
 // @ts-ignore: decorator
@builtin export declare function isInteger<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isFloat<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isSigned<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isReference<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isString<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isArray<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isArrayLike<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isFunction<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isNullable<T>(value?: T): bool;
 // @ts-ignore: decorator
@builtin export declare function isDefined(expression: void): bool;
 // @ts-ignore: decorator
@builtin export declare function isConstant(expression: void): bool;
 // @ts-ignore: decorator
@builtin export declare function isManaged<T>(value?: T): bool;
 // @ts-ignore: decorator
@inline export function isNaN<T>(value: T): bool { return value != value; }
 // @ts-ignore: decorator
@inline export function isFinite<T>(value: T): bool { return value - value == 0; }
 // @ts-ignore: decorator
@builtin export declare function clz<T>(value: T): T;
 // @ts-ignore: decorator
@builtin export declare function ctz<T>(value: T): T;
 // @ts-ignore: decorator
@builtin export declare function popcnt<T>(value: T): T;
 // @ts-ignore: decorator
@builtin export declare function rotl<T>(value: T, shift: T): T;
 // @ts-ignore: decorator
@builtin export declare function rotr<T>(value: T, shift: T): T;
 // @ts-ignore: decorator
@builtin export declare function abs<T>(value: T): T;
 // @ts-ignore: decorator
@builtin export declare function max<T>(left: T, right: T): T;
 // @ts-ignore: decorator
@builtin export declare function min<T>(left: T, right: T): T;
 // @ts-ignore: decorator
@builtin export declare function ceil<T>(value: T): T;
 // @ts-ignore: decorator
@builtin export declare function floor<T>(value: T): T;
 // @ts-ignore: decorator
@builtin export declare function copysign<T>(left: T, right: T): T;
 // @ts-ignore: decorator
@builtin export declare function nearest<T>(value: T): T;
-@builtin export declare function reinterpret<T>(value: void): T;
+// @ts-ignore: decorator
@builtin export declare function reinterpret<T>(value: number): T;
 // @ts-ignore: decorator
@builtin export declare function sqrt<T>(value: T): T;
 // @ts-ignore: decorator
@builtin export declare function trunc<T>(value: T): T;
 // @ts-ignore: decorator
@builtin export declare function load<T>(offset: usize, immOffset?: usize, immAlign?: usize): T;
 // @ts-ignore: decorator
@builtin export declare function store<T>(offset: usize, value: void, immOffset?: usize, immAlign?: usize): void;
 // @ts-ignore: decorator
@builtin export declare function sizeof<T>(): usize; // | u32 / u64
 // @ts-ignore: decorator
@builtin export declare function alignof<T>(): usize; // | u32 / u64
 // @ts-ignore: decorator
@builtin export declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64
 // @ts-ignore: decorator
@builtin export declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;
 // @ts-ignore: decorator
@builtin export declare function unreachable(): void;
 // @ts-ignore: decorator
@builtin export declare function changetype<T>(value: void): T;
 // @ts-ignore: decorator
@builtin export declare function assert<T>(isTrueish: T, message?: string): T;
 // @ts-ignore: decorator
@builtin export declare function unchecked<T>(expr: T): T;
 // @ts-ignore: decorator
@builtin export declare function call_indirect<T>(target: void, ...args: void[]): T;
 // @ts-ignore: decorator
@builtin export declare function instantiate<T>(...args: void[]): T;
 export namespace atomic {
  // @ts-ignore: decorator
  @builtin export declare function load<T>(offset: usize, immOffset?: usize): T;
  // @ts-ignore: decorator
  @builtin export declare function store<T>(offset: usize, value: T, immOffset?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function add<T>(ptr: usize, value: T, immOffset?: usize): T;
  // @ts-ignore: decorator
  @builtin export declare function sub<T>(ptr: usize, value: T, immOffset?: usize): T;
  // @ts-ignore: decorator
  @builtin export declare function and<T>(ptr: usize, value: T, immOffset?: usize): T;
  // @ts-ignore: decorator
  @builtin export declare function or<T>(ptr: usize, value: T, immOffset?: usize): T;
  // @ts-ignore: decorator
  @builtin export declare function xor<T>(ptr: usize, value: T, immOffset?: usize): T;
  // @ts-ignore: decorator
  @builtin export declare function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;
  // @ts-ignore: decorator
  @builtin export declare function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;
  // @ts-ignore: decorator
  @builtin export declare function wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;
  // @ts-ignore: decorator
  @builtin export declare function notify<T>(ptr: usize, count: i32): i32;
  // @ts-ignore: decorators
 }
 // @ts-ignore: decorator
@lazy export const enum AtomicWaitResult {
  OK = 0,
  NOT_EQUAL = 1,
  TIMED_OUT = 2
 }
 // @ts-ignore: decorator
@builtin export declare function i8(value: void): i8;
 export namespace i8 {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: i8 = -128;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: i8 =  127;
 }
 // @ts-ignore: decorator
@builtin export declare function i16(value: void): i16;
 export namespace i16 {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: i16 = -32768;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: i16 =  32767;
 }
 // @ts-ignore: decorator
@builtin export declare function i32(value: void): i32;
 export namespace i32 {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: i32 = -2147483648;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: i32 =  2147483647;
  // @ts-ignore: decorator
  @builtin export declare function clz(value: i32): i32;
  // @ts-ignore: decorator
  @builtin export declare function ctz(value: i32): i32;
  // @ts-ignore: decorator
  @builtin export declare function popcnt(value: i32): i32;
  // @ts-ignore: decorator
  @builtin export declare function rotl(value: i32, shift: i32): i32;
  // @ts-ignore: decorator
  @builtin export declare function rotr(value: i32, shift: i32): i32;
  // @ts-ignore: decorator
  @builtin export declare function reinterpret_f32(value: f32): i32;
  // @ts-ignore: decorator
  @builtin export declare function load8_s(offset: usize, immOffset?: usize, immAlign?: usize): i32;
  // @ts-ignore: decorator
  @builtin export declare function load8_u(offset: usize, immOffset?: usize, immAlign?: usize): i32;
  // @ts-ignore: decorator
  @builtin export declare function load16_s(offset: usize, immOffset?: usize, immAlign?: usize): i32;
  // @ts-ignore: decorator
  @builtin export declare function load16_u(offset: usize, immOffset?: usize, immAlign?: usize): i32;
  // @ts-ignore: decorator
  @builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): i32;
  // @ts-ignore: decorator
  @builtin export declare function store8(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function store16(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function store(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
  export namespace atomic {
    // @ts-ignore: decorator
    @builtin export declare function load8_u(offset: usize, immOffset?: usize): i32;
    // @ts-ignore: decorator
    @builtin export declare function load16_u(offset: usize, immOffset?: usize): i32;
    // @ts-ignore: decorator
    @builtin export declare function load(offset: usize, immOffset?: usize): i32;
    // @ts-ignore: decorator
    @builtin export declare function store8(offset: usize, value: i32, immOffset?: usize): void;
    // @ts-ignore: decorator
    @builtin export declare function store16(offset: usize, value: i32, immOffset?: usize): void;
    // @ts-ignore: decorator
    @builtin export declare function store(offset: usize, value: i32, immOffset?: usize): void;
    // @ts-ignore: decorator
    @builtin export declare function wait(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;
    // @ts-ignore: decorator
    @builtin export declare function notify(ptr: usize, count: i32): i32;
    export namespace rmw8 {
      // @ts-ignore: decorator
      @builtin export declare function add_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function sub_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function and_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function or_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function xor_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function xchg_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function cmpxchg_u(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
    }
    export namespace rmw16 {
      // @ts-ignore: decorator
      @builtin export declare function add_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function sub_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function and_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function or_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function xor_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function xchg_u(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function cmpxchg_u(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
    }
    export namespace rmw {
      // @ts-ignore: decorator
      @builtin export declare function add(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function sub(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function and(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function or(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function xor(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function xchg(offset: usize, value: i32, immOffset?: usize): i32;
      // @ts-ignore: decorator
      @builtin export declare function cmpxchg(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
    }
  }
 }
 // @ts-ignore: decorator
@builtin export declare function i64(value: void): i64;
 export namespace i64 {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: i64 = -9223372036854775808;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: i64 =  9223372036854775807;
  // @ts-ignore: decorator
  @builtin export declare function clz(value: i64): i64;
  // @ts-ignore: decorator
  @builtin export declare function ctz(value: i64): i64;
  // @ts-ignore: decorator
  @builtin export declare function load8_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
  // @ts-ignore: decorator
  @builtin export declare function load8_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
  // @ts-ignore: decorator
  @builtin export declare function load16_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
  // @ts-ignore: decorator
  @builtin export declare function load16_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
  // @ts-ignore: decorator
  @builtin export declare function load32_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
  // @ts-ignore: decorator
  @builtin export declare function load32_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
  // @ts-ignore: decorator
  @builtin export declare function load(offset: usize, immOffset?: usize): i64;
  // @ts-ignore: decorator
  @builtin export declare function popcnt(value: i64): i64;
  // @ts-ignore: decorator
  @builtin export declare function rotl(value: i64, shift: i64): i64;
  // @ts-ignore: decorator
  @builtin export declare function rotr(value: i64, shift: i64): i64;
  // @ts-ignore: decorator
  @builtin export declare function reinterpret_f64(value: f64): i64;
  // @ts-ignore: decorator
  @builtin export declare function store8(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function store16(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function store32(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function store(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
  export namespace atomic {
    // @ts-ignore: decorator
    @builtin export declare function load8_u(offset: usize, immOffset?: usize): i64;
    // @ts-ignore: decorator
    @builtin export declare function load16_u(offset: usize, immOffset?: usize): i64;
    // @ts-ignore: decorator
    @builtin export declare function load32_u(offset: usize, immOffset?: usize): i64;
    // @ts-ignore: decorator
    @builtin export declare function load(offset: usize, immOffset?: usize): i64;
    // @ts-ignore: decorator
    @builtin export declare function store8(offset: usize, value: i64, immOffset?: usize): void;
    // @ts-ignore: decorator
    @builtin export declare function store16(offset: usize, value: i64, immOffset?: usize): void;
    // @ts-ignore: decorator
    @builtin export declare function store32(offset: usize, value: i64, immOffset?: usize): void;
    // @ts-ignore: decorator
    @builtin export declare function store(offset: usize, value: i64, immOffset?: usize): void;
    // @ts-ignore: decorator
    @builtin export declare function wait(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;
    // @ts-ignore: decorator
    @builtin export declare function notify(ptr: usize, count: i32): i32;
    export namespace rmw8 {
      // @ts-ignore: decorator
      @builtin export declare function add_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function and_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function or_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
    }
    export namespace rmw16 {
      // @ts-ignore: decorator
      @builtin export declare function add_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function and_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function or_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
    }
    export namespace rmw32 {
      // @ts-ignore: decorator
      @builtin export declare function add_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function and_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function or_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
    }
    export namespace rmw {
      // @ts-ignore: decorator
      @builtin export declare function add(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function sub(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function and(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function or(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function xor(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function xchg(offset: usize, value: i64, immOffset?: usize): i64;
      // @ts-ignore: decorator
      @builtin export declare function cmpxchg(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
    }
  }
 }
 // @ts-ignore: decorator
@builtin export declare function isize(value: void): isize;
 export namespace isize {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: isize = sizeof<i32>() == sizeof<isize>()
    ? -2147483648
    : <isize>-9223372036854775808;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: isize = sizeof<i32>() == sizeof<isize>()
    ? 2147483647
    : <isize>9223372036854775807;
 }
 // @ts-ignore: decorator
@builtin export declare function u8(value: void): u8;
 export namespace u8 {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: u8 = 0;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: u8 = 255;
 }
 // @ts-ignore: decorator
@builtin export declare function u16(value: void): u16;
 export namespace u16 {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: u16 = 0;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: u16 = 65535;
 }
 // @ts-ignore: decorator
@builtin export declare function u32(value: void): u32;
 export namespace u32 {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: u32 = 0;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: u32 = 4294967295;
 }
 // @ts-ignore: decorator
@builtin export declare function u64(value: void): u64;
 export namespace u64 {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: u64 = 0;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: u64 = 18446744073709551615;
 }
 // @ts-ignore: decorator
@builtin export declare function usize(value: void): usize;
 export namespace usize {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: usize = 0;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: usize = sizeof<u32>() == sizeof<usize>()
    ? 4294967295
    : <usize>18446744073709551615;
 }
 // @ts-ignore: decorator
@builtin export declare function bool(value: void): bool;
 export namespace bool {
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE: bool = false;
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE: bool = true;
 }
 // @ts-ignore: decorator
@builtin export declare function f32(value: void): f32;
 export namespace f32 {
  // @ts-ignore: decorator
  @lazy export const EPSILON = reinterpret<f32>(0x34000000); // 0x1p-23f
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE = reinterpret<f32>(0x00000001); // 0x0.000001p+0f
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE = reinterpret<f32>(0x7F7FFFFF); // 0x1.fffffep+127f
  // @ts-ignore: decorator
  @lazy export const MIN_NORMAL_VALUE = reinterpret<f32>(0x00800000); // 0x1p-126f
  // @ts-ignore: decorator
  @lazy export const MIN_SAFE_INTEGER: f32 = -16777215;
  // @ts-ignore: decorator
  @lazy export const MAX_SAFE_INTEGER: f32 =  16777215;
  // @ts-ignore: decorator
  @builtin export declare function abs(value: f32): f32;
  // @ts-ignore: decorator
  @builtin export declare function ceil(value: f32): f32;
  // @ts-ignore: decorator
  @builtin export declare function copysign(x: f32, y: f32): f32;
  // @ts-ignore: decorator
  @builtin export declare function floor(value: f32): f32;
  // @ts-ignore: decorator
  @builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): f32;
  // @ts-ignore: decorator
  @builtin export declare function max(left: f32, right: f32): f32;
  // @ts-ignore: decorator
  @builtin export declare function min(left: f32, right: f32): f32;
  // @ts-ignore: decorator
  @builtin export declare function nearest(value: f32): f32;
  // @ts-ignore: decorator
  @builtin export declare function reinterpret_i32(value: i32): f32;
  // @ts-ignore: decorator
  @builtin export declare function sqrt(value: f32): f32;
  // @ts-ignore: decorator
  @builtin export declare function store(offset: usize, value: f32, immOffset?: usize, immAlign?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function trunc(value: f32): f32;
 }
 // @ts-ignore: decorator
@builtin export declare function f64(value: void): f64;
 export namespace f64 {
  // @ts-ignore: decorator
  @lazy export const EPSILON = reinterpret<f64>(0x3CB0000000000000); // 0x1p-52
  // @ts-ignore: decorator
  @lazy export const MIN_VALUE = reinterpret<f64>(0x0000000000000001); // 0x0.0000000000001p+0
  // @ts-ignore: decorator
  @lazy export const MAX_VALUE = reinterpret<f64>(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023
  // @ts-ignore: decorator
  @lazy export const MIN_NORMAL_VALUE = reinterpret<f64>(0x0010000000000000); // 0x1p-1022
  // @ts-ignore: decorator
  @lazy export const MIN_SAFE_INTEGER: f64 = -9007199254740991;
  // @ts-ignore: decorator
  @lazy export const MAX_SAFE_INTEGER: f64 =  9007199254740991;
  // @ts-ignore: decorator
  @builtin export declare function abs(value: f64): f64;
  // @ts-ignore: decorator
  @builtin export declare function ceil(value: f64): f64;
  // @ts-ignore: decorator
  @builtin export declare function copysign(x: f64, y: f64): f64;
  // @ts-ignore: decorator
  @builtin export declare function floor(value: f64): f64;
  // @ts-ignore: decorator
  @builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): f64;
  // @ts-ignore: decorator
  @builtin export declare function max(left: f64, right: f64): f64;
  // @ts-ignore: decorator
  @builtin export declare function min(left: f64, right: f64): f64;
  // @ts-ignore: decorator
  @builtin export declare function nearest(value: f64): f64;
  // @ts-ignore: decorator
  @builtin export declare function reinterpret_i64(value: i64): f64;
  // @ts-ignore: decorator
  @builtin export declare function sqrt(value: f64): f64;
  // @ts-ignore: decorator
  @builtin export declare function store(offset: usize, value: f64, immOffset?: usize, immAlign?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function trunc(value: f64): f64;
 }
 // @ts-ignore: decorator
@builtin export declare function v128(a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8, i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8): v128;
 export namespace v128 {
  // @ts-ignore: decorator
  @builtin export declare function splat<T>(x: T): v128;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane<T>(x: v128, idx: u8): T;
  // @ts-ignore: decorator
  @builtin export declare function replace_lane<T>(x: v128, idx: u8, value: T): v128;
  // @ts-ignore: decorator
  @builtin export declare function shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128;
  // @ts-ignore: decorator
  @builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): v128;
  // @ts-ignore: decorator
  @builtin export declare function store(offset: usize, value: v128, immOffset?: usize, immAlign?: usize): void;
  // @ts-ignore: decorator
  @builtin export declare function add<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function mul<T>(a: v128, b: v128): v128; // except i64
  // @ts-ignore: decorator
  @builtin export declare function div<T>(a: v128, b: v128): v128; // f32, f64 only
  // @ts-ignore: decorator
  @builtin export declare function neg<T>(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function add_saturate<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub_saturate<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function shl<T>(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr<T>(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function and(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function or(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function xor(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function not(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function bitselect(v1: v128, v2: v128, c: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function any_true<T>(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function all_true<T>(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function min<T>(a: v128, b: v128): v128; // f32, f64 only
  // @ts-ignore: decorator
  @builtin export declare function max<T>(a: v128, b: v128): v128; // f32, f64 only
  // @ts-ignore: decorator
  @builtin export declare function abs<T>(a: v128): v128; // f32, f64 only
  // @ts-ignore: decorator
  @builtin export declare function sqrt<T>(a: v128): v128; // f32, f64 only
  // @ts-ignore: decorator
  @builtin export declare function eq<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ne<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge<T>(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function convert<T>(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function trunc<T>(a: v128): v128;
 }
 // @ts-ignore: decorator
@builtin export declare function i8x16(a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8, i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8): v128;
 export namespace i8x16 {
  // @ts-ignore: decorator
  @builtin export declare function splat(x: i8): v128;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane_s(x: v128, idx: u8): i8;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane_u(x: v128, idx: u8): u8;
  // @ts-ignore: decorator
  @builtin export declare function replace_lane(x: v128, idx: u8, value: i8): v128;
  // @ts-ignore: decorator
  @builtin export declare function add(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function mul(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function neg(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function add_saturate_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function add_saturate_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub_saturate_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub_saturate_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function shl(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr_s(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr_u(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function any_true(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function all_true(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function eq(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ne(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge_u(a: v128, b: v128): v128;
 }
 // @ts-ignore: decorator
@builtin export declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;
 export namespace i16x8 {
  // @ts-ignore: decorator
  @builtin export declare function splat(x: i16): v128;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane_s(x: v128, idx: u8): i16;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane_u(x: v128, idx: u8): u16;
  // @ts-ignore: decorator
  @builtin export declare function replace_lane(x: v128, idx: u8, value: i16): v128;
  // @ts-ignore: decorator
  @builtin export declare function add(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function mul(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function neg(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function add_saturate_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function add_saturate_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub_saturate_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub_saturate_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function shl(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr_s(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr_u(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function any_true(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function all_true(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function eq(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ne(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge_u(a: v128, b: v128): v128;
 }
 // @ts-ignore: decorator
@builtin export declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;
 export namespace i32x4 {
  // @ts-ignore: decorator
  @builtin export declare function splat(x: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane(x: v128, idx: u8): i32;
  // @ts-ignore: decorator
  @builtin export declare function replace_lane(x: v128, idx: u8, value: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function add(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function mul(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function neg(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function shl(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr_s(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr_u(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function any_true(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function all_true(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function eq(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ne(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge_s(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge_u(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function trunc_s_f32x4_sat(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function trunc_u_f32x4_sat(a: v128): v128;
 }
 // @ts-ignore: decorator
@builtin export declare function i64x2(a: i64, b: i64): v128;
 export namespace i64x2 {
  // @ts-ignore: decorator
  @builtin export declare function splat(x: i64): v128;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane(x: v128, idx: u8): i64;
  // @ts-ignore: decorator
  @builtin export declare function replace_lane(x: v128, idx: u8, value: i64): v128;
  // @ts-ignore: decorator
  @builtin export declare function add(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function mul(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function neg(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function shl(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr_s(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function shr_u(a: v128, b: i32): v128;
  // @ts-ignore: decorator
  @builtin export declare function any_true(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function all_true(a: v128): bool;
  // @ts-ignore: decorator
  @builtin export declare function trunc_s_f64x2_sat(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function trunc_u_f64x2_sat(a: v128): v128;
 }
 // @ts-ignore: decorator
@builtin export declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;
 export namespace f32x4 {
  // @ts-ignore: decorator
  @builtin export declare function splat(x: f32): v128;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane(x: v128, idx: u8): f32;
  // @ts-ignore: decorator
  @builtin export declare function replace_lane(x: v128, idx: u8, value: f32): v128;
  // @ts-ignore: decorator
  @builtin export declare function add(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function mul(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function div(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function neg(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function min(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function max(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function abs(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sqrt(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function eq(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ne(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function convert_s_i32x4(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function convert_u_i32x4(a: v128): v128;
 }
 // @ts-ignore: decorator
@builtin export declare function f64x2(a: f64, b: f64): v128;
 export namespace f64x2 {
  // @ts-ignore: decorator
  @builtin export declare function splat(x: f64): v128;
  // @ts-ignore: decorator
  @builtin export declare function extract_lane(x: v128, idx: u8): f64;
  // @ts-ignore: decorator
  @builtin export declare function replace_lane(x: v128, idx: u8, value: f64): v128;
  // @ts-ignore: decorator
  @builtin export declare function add(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sub(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function mul(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function div(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function neg(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function min(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function max(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function abs(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function sqrt(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function eq(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ne(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function lt(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function le(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function gt(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function ge(a: v128, b: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function convert_s_i64x2(a: v128): v128;
  // @ts-ignore: decorator
  @builtin export declare function convert_u_i64x2(a: v128): v128;
 }
 export namespace v8x16 {
  // @ts-ignore: decorator
  @builtin export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8, l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8): v128;
 }
--- a/std/assembly/collector/itcm.ts
+++ b/std/assembly/collector/itcm.ts
@ -1,8 +1,10 @@
 // Largely based on Bach Le's μgc, see: https://github.com/bullno1/ugc
 // @ts-ignore: decorator
@inline const TRACE = false;
 /** Size of a managed object header. */
 // @ts-ignore: decorator
@inline export const HEADER_SIZE: usize = (offsetof<ManagedObject>() + AL_MASK) & ~AL_MASK;
 import { AL_MASK, MAX_SIZE_32 } from "../util/allocator";
@ -146,6 +148,7 @@ function step(): void {
      if (obj !== toSpace) {
        if (TRACE) trace("gc~step/MARK iterate", 1, objToRef(obj));
        iter = obj;
        // @ts-ignore: cast
        obj.color = <i32>!white;
        // if (TRACE) {
        //   trace("   next/prev/hook", 3,
@ -163,6 +166,7 @@ function step(): void {
          let from = fromSpace;
          fromSpace = toSpace;
          toSpace = from;
          // @ts-ignore: cast
          white = <i32>!white;
          iter = from.next;
          state = State.SWEEP;
@ -188,14 +192,17 @@ function step(): void {
  }
 }
 // @ts-ignore: decorator
@inline function refToObj(ref: usize): ManagedObject {
  return changetype<ManagedObject>(ref - HEADER_SIZE);
 }
 // @ts-ignore: decorator
@inline function objToRef(obj: ManagedObject): usize {
  return changetype<usize>(obj) + HEADER_SIZE;
 }
 // @ts-ignore: decorator
@global @unsafe export function __gc_allocate( // TODO: make this register only / reuse header
  size: usize,
  markFn: (ref: usize) => void
@ -210,12 +217,15 @@ function step(): void {
  return objToRef(obj);
 }
 // @ts-ignore: decorator
@global @unsafe export function __gc_link(parentRef: usize, childRef: usize): void {
  if (TRACE) trace("gc.link", 2, parentRef, childRef);
  var parent = refToObj(parentRef);
  // @ts-ignore: cast
  if (parent.color == <i32>!white && refToObj(childRef).color == white) parent.makeGray();
 }
 // @ts-ignore: decorator
@global @unsafe export function __gc_mark(ref: usize): void {
  if (TRACE) trace("gc.mark", 1, ref);
  if (ref) {
@ -224,6 +234,7 @@ function step(): void {
  }
 }
 // @ts-ignore: decorator
@global @unsafe export function __gc_collect(): void {
  if (TRACE) trace("gc.collect");
  // begin collecting if not yet collecting
--- a/std/assembly/diagnostics.ts
+++ b/std/assembly/diagnostics.ts
@ -1,3 +1,8 @@
 // @ts-ignore: decorator
@builtin export declare function ERROR(message?: string): void;
 // @ts-ignore: decorator
@builtin export declare function WARNING(message?: string): void;
 // @ts-ignore: decorator
@builtin export declare function INFO(message?: string): void;
--- a/std/assembly/gc.ts
+++ b/std/assembly/gc.ts
@ -2,6 +2,7 @@
 export namespace gc {
  /** Whether the garbage collector interface is implemented. */
  // @ts-ignore: decorator, undefined
  @lazy export const implemented: bool = isDefined(__gc_register);
  /** Gets the computed unique class id of a class type. */
@ -12,24 +13,28 @@ export namespace gc {
  /** Registers a managed object to be tracked by the garbage collector. */
  @unsafe export function register(ref: usize): void {
    // @ts-ignore: undefined
    if (isDefined(__gc_register)) __gc_register(ref);
    else ERROR("missing implementation: gc.register");
  }
  /** Links a registered object with the registered object now referencing it. */
  @unsafe export function link(ref: usize, parentRef: usize): void {
    // @ts-ignore: undefined
    if (isDefined(__gc_link)) __gc_link(ref, parentRef);
    else ERROR("missing implementation: gc.link");
  }
  /** Marks an object as being reachable. */
  @unsafe export function mark(ref: usize): void {
    // @ts-ignore: undefined
    if (isDefined(__gc_mark)) __gc_mark(ref);
    else ERROR("missing implementation: gc.mark");
  }
  /** Performs a full garbage collection cycle. */
  export function collect(): void {
    // @ts-ignore: undefined
    if (isDefined(__gc_collect)) __gc_collect();
    else WARNING("missing implementation: gc.collect");
  }
--- a/std/assembly/map.ts
+++ b/std/assembly/map.ts
@ -3,8 +3,13 @@ import { HASH } from "./util/hash";
 // A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht
 // @ts-ignore: decorator
@inline const INITIAL_CAPACITY = 4;
 // @ts-ignore: decorator
@inline const FILL_FACTOR: f64 = 8 / 3;
 // @ts-ignore: decorator
@inline const FREE_FACTOR: f64 = 3 / 4;
 /** Structure of a map entry. */
@ -15,12 +20,15 @@ import { HASH } from "./util/hash";
 }
 /** Empty bit. */
 // @ts-ignore: decorator
@inline const EMPTY: usize = 1 << 0;
 /** Size of a bucket. */
 // @ts-ignore: decorator
@inline const BUCKET_SIZE = sizeof<usize>();
 /** Computes the alignment of an entry. */
 // @ts-ignore: decorator
@inline function ENTRY_ALIGN<K,V>(): usize {
  // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits
  const maxkv = sizeof<K>() > sizeof<V>() ? sizeof<K>() : sizeof<V>();
@ -29,6 +37,7 @@ import { HASH } from "./util/hash";
 }
 /** Computes the aligned size of an entry. */
 // @ts-ignore: decorator
@inline function ENTRY_SIZE<K,V>(): usize {
  const align = ENTRY_ALIGN<K,V>();
  const size = (offsetof<MapEntry<K,V>>() + align) & ~align;
--- a/std/assembly/math.ts
+++ b/std/assembly/math.ts
@ -42,6 +42,7 @@ function R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3
  return p / q;
 }
 // @ts-ignore: decorator
@inline function expo2(x: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)
  const                       // see: musl/src/math/__expo2.c
    k    = <u32>2043,
@ -50,11 +51,15 @@ function R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3
  return NativeMath.exp(x - kln2) * scale * scale;
 }
-/** @internal */
+// @ts-ignore: decorator
@lazy var random_seeded = false;
 // @ts-ignore: decorator
@lazy var random_state0_64: u64;
 // @ts-ignore: decorator
@lazy var random_state1_64: u64;
 // @ts-ignore: decorator
@lazy var random_state0_32: u32;
 // @ts-ignore: decorator
@lazy var random_state1_32: u32;
 function murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche
@ -75,17 +80,25 @@ function splitMix32(h: u32): u32 {
 export namespace NativeMath {
  // @ts-ignore: decorator
  @lazy export const E       = reinterpret<f64>(0x4005BF0A8B145769); // 2.7182818284590452354
  // @ts-ignore: decorator
  @lazy export const LN2     = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.69314718055994530942
  // @ts-ignore: decorator
  @lazy export const LN10    = reinterpret<f64>(0x40026BB1BBB55516); // 2.30258509299404568402
  // @ts-ignore: decorator
  @lazy export const LOG2E   = reinterpret<f64>(0x3FF71547652B82FE); // 1.4426950408889634074
  // @ts-ignore: decorator
  @lazy export const LOG10E  = reinterpret<f64>(0x3FDBCB7B1526E50E); // 0.43429448190325182765
  // @ts-ignore: decorator
  @lazy export const PI      = reinterpret<f64>(0x400921FB54442D18); // 3.14159265358979323846
  // @ts-ignore: decorator
  @lazy export const SQRT1_2 = reinterpret<f64>(0x3FE6A09E667F3BCD); // 0.70710678118654752440
  // @ts-ignore: decorator
  @lazy export const SQRT2   = reinterpret<f64>(0x3FF6A09E667F3BCD); // 1.41421356237309504880
-  @inline
+  // @ts-ignore: decorator
-  export function abs(x: f64): f64 {
+  @inline export function abs(x: f64): f64 {
    return builtin_abs<f64>(x);
  }
@ -346,8 +359,8 @@ export namespace NativeMath {
    return t;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function ceil(x: f64): f64 {
+  @inline export function ceil(x: f64): f64 {
    return builtin_ceil<f64>(x);
  }
@ -497,13 +510,13 @@ export namespace NativeMath {
    return (x + y) * twopk;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function floor(x: f64): f64 {
+  @inline export function floor(x: f64): f64 {
    return builtin_floor<f64>(x);
  }
-  @inline
+  // @ts-ignore: decorator
-  export function fround(x: f64): f32 {
+  @inline export function fround(x: f64): f32 {
    return <f32>x;
  }
@ -763,13 +776,13 @@ export namespace NativeMath {
    return val_lo + val_hi;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function max(value1: f64, value2: f64): f64 {
+  @inline export function max(value1: f64, value2: f64): f64 {
    return builtin_max<f64>(value1, value2);
  }
-  @inline
+  // @ts-ignore: decorator
-  export function min(value1: f64, value2: f64): f64 {
+  @inline export function min(value1: f64, value2: f64): f64 {
    return builtin_min<f64>(value1, value2);
  }
@ -997,13 +1010,13 @@ export namespace NativeMath {
    return reinterpret<f64>(r) - 1;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function round(x: f64): f64 {
+  @inline export function round(x: f64): f64 {
    return builtin_copysign<f64>(builtin_floor<f64>(x + 0.5), x);
  }
-  @inline
+  // @ts-ignore: decorator
-  export function sign(x: f64): f64 {
+  @inline export function sign(x: f64): f64 {
    if (ASC_SHRINK_LEVEL > 0) {
      return builtin_abs(x) > 0 ? builtin_copysign<f64>(1, x) : x;
    } else {
@ -1011,10 +1024,11 @@ export namespace NativeMath {
    }
  }
-  @inline
+  // @ts-ignore: decorator
-  export function signbit(x: f64): bool {
+  @inline export function signbit(x: f64): bool {
    // In ECMAScript all NaN values are indistinguishable from each other
    // so we need handle NaN and negative NaN in similar way
    // @ts-ignore: type
    return <bool>(<i32>(reinterpret<u64>(x) >>> 63) & (x == x));
  }
@ -1041,8 +1055,8 @@ export namespace NativeMath {
    return t;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function sqrt(x: f64): f64 {
+  @inline export function sqrt(x: f64): f64 {
    return builtin_sqrt<f64>(x);
  }
@ -1074,8 +1088,8 @@ export namespace NativeMath {
    return builtin_copysign<f64>(t, x);
  }
-  @inline
+  // @ts-ignore: decorator
-  export function trunc(x: f64): f64 {
+  @inline export function trunc(x: f64): f64 {
    return builtin_trunc<f64>(x);
  }
@ -1232,8 +1246,9 @@ export namespace NativeMath {
  }
 }
-/** @internal */
+// @ts-ignore: decorator
@lazy var rempio2f_y: f64;
 // @ts-ignore: decorator
@lazy const PIO2_TABLE: u64[] = [
  0xA2F9836E4E441529,
  0xFC2757D1F534DDC0,
@ -1241,7 +1256,6 @@ export namespace NativeMath {
  0xFE5163ABDEBBC561
 ];
 /** @internal */
 function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3
  const                    // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above
    pS0 = reinterpret<f32>(0x3E2AAA75), //  1.6666586697e-01f
@ -1253,6 +1267,7 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3
  return p / q;
 }
 // @ts-ignore: decorator
@inline function expo2f(x: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)
  const                                // see: musl/src/math/__expo2f.c
    k    = <u32>235,
@ -1261,8 +1276,8 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3
  return NativeMathf.exp(x - kln2) * scale * scale;
 }
-@inline /** @internal */
+// @ts-ignore: decorator
-function pio2_large_quot(x: f32, u: i32): i32 {       // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c
+@inline function pio2_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c
  const coeff = reinterpret<f64>(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20
  const bits = PIO2_TABLE;
@ -1291,8 +1306,8 @@ function pio2_large_quot(x: f32, u: i32): i32 {       // see: jdh8/metallic/blob
  return q;
 }
-@inline /** @internal */
+// @ts-ignore: decorator
-function rempio2f(x: f32, u: u32, sign: i32): i32 {   // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c
+@inline function rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c
  const pi2hi = reinterpret<f64>(0x3FF921FB50000000); // 1.57079631090164184570
  const pi2lo = reinterpret<f64>(0x3E5110B4611A6263); // 1.58932547735281966916e-8
  const _2_pi = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308
@ -1308,8 +1323,8 @@ function rempio2f(x: f32, u: u32, sign: i32): i32 {   // see: jdh8/metallic/blob
 }
 /* |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]). */
-@inline /** @internal */
+// @ts-ignore: decorator
-function sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c
+@inline function sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c
  const S1 = reinterpret<f64>(0xBFC5555554CBAC77); // -0x15555554cbac77.0p-55
  const S2 = reinterpret<f64>(0x3F811110896EFBB2); //  0x111110896efbb2.0p-59
  const S3 = reinterpret<f64>(0xBF2A00F9E2CAE774); // -0x1a00f9e2cae774.0p-65
@ -1323,8 +1338,8 @@ function sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c
 }
 /* |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]). */
-@inline /** @internal */
+// @ts-ignore: decorator
-function cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c
+@inline function cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c
  const C0 = reinterpret<f64>(0xBFDFFFFFFD0C5E81); // -0x1ffffffd0c5e81.0p-54
  const C1 = reinterpret<f64>(0x3FA55553E1053A42); //  0x155553e1053a42.0p-57
  const C2 = reinterpret<f64>(0xBF56C087E80F1E27); // -0x16c087e80f1e27.0p-62
@ -1337,8 +1352,8 @@ function cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c
 }
 /* |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]). */
-@inline /** @internal */
+// @ts-ignore: decorator
-function tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c
+@inline function tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c
  const T0 = reinterpret<f64>(0x3FD5554D3418C99F); /* 0x15554d3418c99f.0p-54 */
  const T1 = reinterpret<f64>(0x3FC112FD38999F72); /* 0x1112fd38999f72.0p-55 */
@ -1360,21 +1375,31 @@ function tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c
 export namespace NativeMathf {
  // @ts-ignore: decorator
  @lazy export const E       = <f32>NativeMath.E;
  // @ts-ignore: decorator
  @lazy export const LN2     = <f32>NativeMath.LN2;
  // @ts-ignore: decorator
  @lazy export const LN10    = <f32>NativeMath.LN10;
  // @ts-ignore: decorator
  @lazy export const LOG2E   = <f32>NativeMath.LOG2E;
  // @ts-ignore: decorator
  @lazy export const LOG10E  = <f32>NativeMath.LOG10E;
  // @ts-ignore: decorator
  @lazy export const PI      = <f32>NativeMath.PI;
  // @ts-ignore: decorator
  @lazy export const SQRT1_2 = <f32>NativeMath.SQRT1_2;
  // @ts-ignore: decorator
  @lazy export const SQRT2   = <f32>NativeMath.SQRT2;
  /** Used as return values from Mathf.sincos */
  // @ts-ignore: decorator
  @lazy export var sincos_sin: f32 = 0;
  // @ts-ignore: decorator
  @lazy export var sincos_cos: f32 = 0;
-  @inline
+  // @ts-ignore: decorator
-  export function abs(x: f32): f32 {
+  @inline export function abs(x: f32): f32 {
    return builtin_abs<f32>(x);
  }
@ -1609,8 +1634,8 @@ export namespace NativeMathf {
    return <f32>t;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function ceil(x: f32): f32 {
+  @inline export function ceil(x: f32): f32 {
    return builtin_ceil<f32>(x);
  }
@ -1685,8 +1710,8 @@ export namespace NativeMathf {
    return expo2f(x);
  }
-  @inline
+  // @ts-ignore: decorator
-  export function floor(x: f32): f32 {
+  @inline export function floor(x: f32): f32 {
    return builtin_floor<f32>(x);
  }
@ -1796,8 +1821,8 @@ export namespace NativeMathf {
    return (x + y) * twopk;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function fround(x: f32): f32 {
+  @inline export function fround(x: f32): f32 {
    return x;
  }
@ -1831,8 +1856,8 @@ export namespace NativeMathf {
    return z * builtin_sqrt<f32>(<f32>(<f64>x * x + <f64>y * y));
  }
-  @inline
+  // @ts-ignore: decorator
-  export function imul(x: f32, y: f32): f32 {
+  @inline export function imul(x: f32, y: f32): f32 {
    /*
     * Wasm (MVP) and JS have different approaches for double->int conversions.
     *
@ -2010,13 +2035,13 @@ export namespace NativeMathf {
    return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function max(value1: f32, value2: f32): f32 {
+  @inline export function max(value1: f32, value2: f32): f32 {
    return builtin_max<f32>(value1, value2);
  }
-  @inline
+  // @ts-ignore: decorator
-  export function min(value1: f32, value2: f32): f32 {
+  @inline export function min(value1: f32, value2: f32): f32 {
    return builtin_min<f32>(value1, value2);
  }
@ -2209,8 +2234,8 @@ export namespace NativeMathf {
    return sn * z;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function seedRandom(value: i64): void {
+  @inline export function seedRandom(value: i64): void {
    NativeMath.seedRandom(value);
  }
@ -2229,13 +2254,13 @@ export namespace NativeMathf {
    return reinterpret<f32>((r >> 9) | (127 << 23)) - 1.0;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function round(x: f32): f32 {
+  @inline export function round(x: f32): f32 {
    return builtin_copysign<f32>(builtin_floor<f32>(x + 0.5), x);
  }
-  @inline
+  // @ts-ignore: decorator
-  export function sign(x: f32): f32 {
+  @inline export function sign(x: f32): f32 {
    if (ASC_SHRINK_LEVEL > 0) {
      return builtin_abs(x) > 0 ? builtin_copysign<f32>(1, x) : x;
    } else {
@ -2243,8 +2268,9 @@ export namespace NativeMathf {
    }
  }
-  @inline
+  // @ts-ignore: decorator
-  export function signbit(x: f32): bool {
+  @inline export function signbit(x: f32): bool {
    // @ts-ignore: type
    return <bool>((reinterpret<u32>(x) >>> 31) & (x == x));
  }
@ -2308,8 +2334,8 @@ export namespace NativeMathf {
    return t;
  }
-  @inline
+  // @ts-ignore: decorator
-  export function sqrt(x: f32): f32 {
+  @inline export function sqrt(x: f32): f32 {
    return builtin_sqrt<f32>(x);
  }
@ -2377,8 +2403,8 @@ export namespace NativeMathf {
    return builtin_copysign<f32>(t, x);
  }
-  @inline
+  // @ts-ignore: decorator
-  export function trunc(x: f32): f32 {
+  @inline export function trunc(x: f32): f32 {
    return builtin_trunc<f32>(x);
  }
@ -2541,12 +2567,12 @@ export namespace NativeMathf {
    if (ix <= 0x3f490fda) {  /* |x| ~<= π/4 */
      if (ix < 0x39800000) { /* |x| < 2**-12 */
-        sincos_s32 = x;
+        sincos_sin = x;
-        sincos_c32 = 1;
+        sincos_cos = 1;
        return;
      }
-      sincos_s32 = sin_kernf(x);
+      sincos_sin = sin_kernf(x);
-      sincos_c32 = cos_kernf(x);
+      sincos_cos = cos_kernf(x);
      return;
    }
@ -2554,33 +2580,33 @@ export namespace NativeMathf {
      if (ix <= 0x407b53d1) {   /* |x| ~<= 5π/4 */
        if (ix <= 0x4016cbe3) { /* |x| ~<= 3π/4 */
          if (sign) {
-            sincos_s32 = -cos_kernf(x + s1pio2);
+            sincos_sin = -cos_kernf(x + s1pio2);
-            sincos_c32 =  sin_kernf(x + s1pio2);
+            sincos_cos =  sin_kernf(x + s1pio2);
          } else {
-            sincos_s32 = cos_kernf(s1pio2 - x);
+            sincos_sin = cos_kernf(s1pio2 - x);
-            sincos_c32 = sin_kernf(s1pio2 - x);
+            sincos_cos = sin_kernf(s1pio2 - x);
          }
          return;
        }
        /* -sin(x + c) is not correct if x+c could be 0: -0 vs +0 */
-        sincos_s32 = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);
+        sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);
-        sincos_c32 = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);
+        sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);
        return;
      }
      if (ix <= 0x40e231d5) {   /* |x| ~<= 9π/4 */
        if (ix <= 0x40afeddf) { /* |x| ~<= 7π/4 */
          if (sign) {
-            sincos_s32 =  cos_kernf(x + s3pio2);
+            sincos_sin =  cos_kernf(x + s3pio2);
-            sincos_c32 = -sin_kernf(x + s3pio2);
+            sincos_cos = -sin_kernf(x + s3pio2);
          } else {
-            sincos_s32 = -cos_kernf(x - s3pio2);
+            sincos_sin = -cos_kernf(x - s3pio2);
-            sincos_c32 =  sin_kernf(x - s3pio2);
+            sincos_cos =  sin_kernf(x - s3pio2);
          }
          return;
        }
-        sincos_s32 = sin_kernf(sign ? x + s4pio2 : x - s4pio2);
+        sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);
-        sincos_c32 = cos_kernf(sign ? x + s4pio2 : x - s4pio2);
+        sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);
        return;
      }
    }
@ -2588,8 +2614,8 @@ export namespace NativeMathf {
    /* sin(Inf or NaN) is NaN */
    if (ix >= 0x7f800000) {
      let xx = x - x;
-      sincos_s32 = xx;
+      sincos_sin = xx;
-      sincos_c32 = xx;
+      sincos_cos = xx;
      return;
    }
@ -2601,24 +2627,24 @@ export namespace NativeMathf {
    switch (n & 3) {
      case 0: {
-        sincos_s32 = s;
+        sincos_sin = s;
-        sincos_c32 = c;
+        sincos_cos = c;
        break;
      }
      case 1: {
-        sincos_s32 =  c;
+        sincos_sin =  c;
-        sincos_c32 = -s;
+        sincos_cos = -s;
        break;
      }
      case 2: {
-        sincos_s32 = -s;
+        sincos_sin = -s;
-        sincos_c32 = -c;
+        sincos_cos = -c;
        break;
      }
      case 3:
      default: {
-        sincos_s32 = -c;
+        sincos_sin = -c;
-        sincos_c32 =  s;
+        sincos_cos =  s;
        break;
      }
    }
--- a/std/assembly/memory.ts
+++ b/std/assembly/memory.ts
@ -1,56 +1,70 @@
 import { memcmp, memmove, memset } from "./util/memory";
 // @ts-ignore: decorator
@builtin export declare const HEAP_BASE: usize;
 /** Memory manager interface. */
 export namespace memory {
  /** Gets the size of the memory in pages. */
  // @ts-ignore: decorator
  @builtin export declare function size(): i32;
  /** Grows the memory by the given size in pages and returns the previous size in pages. */
  // @ts-ignore: decorator
  @unsafe @builtin export declare function grow(pages: i32): i32;
  /** Fills a section in memory with the specified byte value. */
  // @ts-ignore: decorator
  @unsafe @builtin export function fill(dst: usize, c: u8, n: usize): void {
    memset(dst, c, n); // fallback if "bulk-memory" isn't enabled
  }
  /** Copies a section of memory to another. Has move semantics. */
  // @ts-ignore: decorator
  @unsafe @builtin export function copy(dst: usize, src: usize, n: usize): void {
    memmove(dst, src, n); // fallback if "bulk-memory" isn't enabled
  }
  /** Initializes a memory segment. */
  // @ts-ignore: decorator
  @unsafe export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {
    ERROR("not implemented");
  }
  /** Drops a memory segment. */
  // @ts-ignore: decorator
  @unsafe export function drop(segmentIndex: u32): void {
    ERROR("not implemented");
  }
  /** Dynamically allocates a section of memory and returns its address. */
  // @ts-ignore: decorator
  @unsafe export function allocate(size: usize): usize {
    // @ts-ignore: undefined
    if (isDefined(__memory_allocate)) return __memory_allocate(size);
    else ERROR("missing implementation: memory.allocate");
    return <usize>unreachable();
  }
  /** Dynamically frees a section of memory by the previously allocated address. */
  // @ts-ignore: decorator
  @unsafe export function free(ptr: usize): void {
    // @ts-ignore: undefined
    if (isDefined(__memory_free)) __memory_free(ptr);
    else ERROR("missing implementation: memory.free");
  }
  /** Resets the memory to its initial state. Arena allocator only. */
  // @ts-ignore: decorator
  @unsafe export function reset(): void {
    // @ts-ignore: undefined
    if (isDefined(__memory_reset)) __memory_reset();
    else ERROR("missing implementation: memory.reset");
  }
  /** Repeats a section of memory at a specific address. */
  // @ts-ignore: decorator
  @unsafe export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {
    var index: usize = 0;
    var total = srcLength * count;
@ -61,6 +75,7 @@ export namespace memory {
  }
  /** Compares a section of memory to another. */
  // @ts-ignore: decorator
  @inline export function compare(vl: usize, vr: usize, n: usize): i32 {
    return memcmp(vl, vr, n);
  }
--- a/std/assembly/number.ts
+++ b/std/assembly/number.ts
@ -3,7 +3,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class I8 {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: i8 = i8.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: i8 = i8.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): i8 {
@ -18,7 +20,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class I16 {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: i16 = i16.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: i16 = i16.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): i16 {
@ -33,7 +37,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class I32 {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: i32 = i32.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: i32 = i32.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): i32 {
@ -48,7 +54,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class I64 {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: i64 = i64.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: i64 = i64.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): i64 {
@ -63,7 +71,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class Isize {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: isize = isize.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: isize = isize.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): isize {
@ -78,7 +88,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class U8 {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: u8 = u8.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: u8 = u8.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): u8 {
@ -93,7 +105,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class U16 {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: u16 = u16.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: u16 = u16.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): u16 {
@ -108,7 +122,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class U32 {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: u32 = u32.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: u32 = u32.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): u32 {
@ -123,7 +139,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class U64 {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: u64 = u64.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: u64 = u64.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): u64 {
@ -138,7 +156,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class Usize {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: usize = usize.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: usize = usize.MAX_VALUE;
  static parseInt(value: string, radix: i32 = 0): usize {
@ -153,7 +173,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class Bool {
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: bool = bool.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: bool = bool.MAX_VALUE;
  toString(this: bool): String {
@ -166,13 +188,21 @@ export { Bool as Boolean };
@sealed export abstract class F32 {
  // @ts-ignore: decorator
  @lazy static readonly EPSILON: f32 = f32.EPSILON;
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: f32 = f32.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: f32 = f32.MAX_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;
  // @ts-ignore: decorator
  @lazy static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;
  // @ts-ignore: decorator
  @lazy static readonly POSITIVE_INFINITY: f32 = Infinity;
  // @ts-ignore: decorator
  @lazy static readonly NEGATIVE_INFINITY: f32 = -Infinity;
  // @ts-ignore: decorator
  @lazy static readonly NaN: f32 = NaN;
  static isNaN(value: f32): bool {
@ -207,13 +237,21 @@ export { Bool as Boolean };
@sealed export abstract class F64 {
  // @ts-ignore: decorator
  @lazy static readonly EPSILON: f64 = f64.EPSILON;
  // @ts-ignore: decorator
  @lazy static readonly MIN_VALUE: f64 = f64.MIN_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MAX_VALUE: f64 = f64.MAX_VALUE;
  // @ts-ignore: decorator
  @lazy static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;
  // @ts-ignore: decorator
  @lazy static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;
  // @ts-ignore: decorator
  @lazy static readonly POSITIVE_INFINITY: f64 = Infinity;
  // @ts-ignore: decorator
  @lazy static readonly NEGATIVE_INFINITY: f64 = -Infinity;
  // @ts-ignore: decorator
  @lazy static readonly NaN: f64 = NaN;
  static isNaN(value: f64): bool {
--- a/std/assembly/polyfills.ts
+++ b/std/assembly/polyfills.ts
@ -25,7 +25,7 @@ export function bswap<T extends number>(value: T): T {
  return value;
 }
-@inline export function bswap16<T extends number>(value: T): T {
+export function bswap16<T extends number>(value: T): T {
  if (isInteger<T>() && sizeof<T>() <= 4) {
    if (sizeof<T>() == 2) {
      return <T>((value << 8) | ((value >> 8) & <T>0x00FF));
--- a/std/assembly/runtime.ts
+++ b/std/assembly/runtime.ts
@ -9,11 +9,13 @@ export namespace runtime {
  @unmanaged export class Header {
    /** Size of a runtime header. */
    // @ts-ignore: decorator
    @lazy @inline static readonly SIZE: usize = gc.implemented
      ? (offsetof<Header>(     ) + AL_MASK) & ~AL_MASK  // full header if GC is present
      : (offsetof<Header>("gc1") + AL_MASK) & ~AL_MASK; // half header if GC is absent
    /** Magic value used to validate runtime headers. */
    // @ts-ignore: decorator
    @lazy @inline static readonly MAGIC: u32 = 0xA55E4B17;
    /** Unique id of the respective class or a magic value if not yet registered.*/
@ -42,6 +44,7 @@ export namespace runtime {
  }
  /** Allocates a new object and returns a pointer to its payload. Does not fill. */
  // @ts-ignore: decorator
  @unsafe export function allocRaw(payloadSize: u32): usize {
    var header = changetype<Header>(memory.allocate(adjust(payloadSize)));
    header.classId = Header.MAGIC;
@ -54,6 +57,7 @@ export namespace runtime {
  }
  /** Allocates a new object and returns a pointer to its payload. Fills with zeroes.*/
  // @ts-ignore: decorator
  @unsafe export function alloc(payloadSize: u32): usize {
    var ref = allocRaw(payloadSize);
    memory.fill(ref, 0, payloadSize);
@ -61,6 +65,7 @@ export namespace runtime {
  }
  /** Reallocates an object if necessary. Returns a pointer to its (moved) payload. */
  // @ts-ignore: decorator
  @unsafe export function realloc(ref: usize, newPayloadSize: u32): usize {
    // Background: When managed objects are allocated these aren't immediately registered with GC
    // but can be used as scratch objects while unregistered. This is useful in situations where
@ -111,11 +116,13 @@ export namespace runtime {
  }
  /** Frees an object. Must not have been registered with GC yet. */
  // @ts-ignore: decorator
  @unsafe @inline export function free<T>(ref: T): void {
    memory.free(changetype<usize>(unref(changetype<usize>(ref))));
  }
  /** Registers a managed object. Cannot be free'd anymore afterwards. */
  // @ts-ignore: decorator
  @unsafe @inline export function register<T>(ref: usize): T {
    if (!isReference<T>()) ERROR("reference expected");
    // see comment in REALLOC why this is useful. also inline this because
@ -126,6 +133,7 @@ export namespace runtime {
  }
  /** Links a managed object with its managed parent. */
  // @ts-ignore: decorator
  @unsafe @inline export function link<T, TParent>(ref: T, parentRef: TParent): void {
    assert(changetype<usize>(ref) >= HEAP_BASE + Header.SIZE); // must be a heap object
    var header = changetype<Header>(changetype<usize>(ref) - Header.SIZE);
@ -141,8 +149,11 @@ export abstract class ArrayBufferView {
  [key: number]: number;
  // @ts-ignore: decorator
  @unsafe data: ArrayBuffer;
  // @ts-ignore: decorator
  @unsafe dataStart: usize;
  // @ts-ignore: decorator
  @unsafe dataEnd: usize;
  constructor(length: i32, alignLog2: i32) {
--- a/std/assembly/set.ts
+++ b/std/assembly/set.ts
@ -3,8 +3,11 @@ import { HASH } from "./util/hash";
 // A deterministic hash set based on CloseTable from https://github.com/jorendorff/dht
 // @ts-ignore: decorator
@inline const INITIAL_CAPACITY = 4;
 // @ts-ignore: decorator
@inline const FILL_FACTOR: f64 = 8 / 3;
 // @ts-ignore: decorator
@inline const FREE_FACTOR: f64 = 3 / 4;
 /** Structure of a set entry. */
@ -14,12 +17,15 @@ import { HASH } from "./util/hash";
 }
 /** Empty bit. */
 // @ts-ignore: decorator
@inline const EMPTY: usize = 1 << 0;
 /** Size of a bucket. */
 // @ts-ignore: decorator
@inline const BUCKET_SIZE = sizeof<usize>();
 /** Computes the alignment of an entry. */
 // @ts-ignore: decorator
@inline function ENTRY_ALIGN<K>(): usize {
  // can align to 4 instead of 8 if 32-bit and K is <= 32-bits
  const align = (sizeof<K>() > sizeof<usize>() ? sizeof<K>() : sizeof<usize>()) - 1;
@ -27,6 +33,7 @@ import { HASH } from "./util/hash";
 }
 /** Computes the aligned size of an entry. */
 // @ts-ignore: decorator
@inline function ENTRY_SIZE<K>(): usize {
  const align = ENTRY_ALIGN<K>();
  const size = (offsetof<SetEntry<K>>() + align) & ~align;
--- a/std/assembly/string.ts
+++ b/std/assembly/string.ts
@ -3,6 +3,7 @@ import { MAX_SIZE_32 } from "./util/allocator";
 import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./util/string";
@sealed export abstract class String {
  // @ts-ignore: decorator
  @lazy static readonly MAX_LENGTH: i32 = (MAX_SIZE_32 - runtime.Header.SIZE) >> alignof<u16>();
  get length(): i32 {
@ -19,6 +20,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
  static fromCodePoint(code: i32): String {
    assert(<u32>code <= 0x10FFFF);
    var sur = code > 0xFFFF;
    // @ts-ignore: type
    var out = runtime.allocRaw((<i32>sur + 1) << 1);
    if (!sur) {
      store<u16>(out, <u16>code);
@ -80,6 +82,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
    var searchLength: isize = searchString.length;
    var start: isize = end - searchLength;
    if (start < 0) return false;
    // @ts-ignore: string/String
    return !compareImpl(this, start, searchString, 0, searchLength);
  }
@ -88,6 +91,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
    if (left === null || right === null) return false;
    var leftLength = left.length;
    if (leftLength != right.length) return false;
    // @ts-ignore: string/String
    return !compareImpl(left, 0, right, 0, leftLength);
  }
@ -101,6 +105,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
    var rightLength = right.length;
    if (!leftLength)  return false;
    if (!rightLength) return true;
    // @ts-ignore: string/String
    return compareImpl(left, 0, right, 0, min(leftLength, rightLength)) > 0;
  }
@ -114,6 +119,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
    var rightLength = right.length;
    if (!rightLength) return false;
    if (!leftLength)  return true;
    // @ts-ignore: string/String
    return compareImpl(left, 0, right, 0, min(leftLength, rightLength)) < 0;
  }
@ -135,6 +141,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
    var start = min<isize>(max<isize>(fromIndex, 0), len);
    len -= searchLen;
    for (let k: isize = start; k <= len; ++k) {
      // @ts-ignore: string/String
      if (!compareImpl(this, k, searchString, 0, searchLen)) return <i32>k;
    }
    return -1;
@ -149,6 +156,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
    if (!len) return -1;
    var start = min<isize>(max(fromIndex, 0), len - searchLen);
    for (let k = start; k >= 0; --k) {
      // @ts-ignore: string/String
      if (!compareImpl(this, k, searchString, 0, searchLen)) return <i32>k;
    }
    return -1;
@ -162,6 +170,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
    var start = min(max(pos, 0), len);
    var searchLength: isize = searchString.length;
    if (searchLength + start > len) return false;
    // @ts-ignore: string/String
    return !compareImpl(this, start, searchString, 0, searchLength);
  }
@ -510,17 +519,21 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
  }
 }
 // @ts-ignore: nolib
 export type string = String;
 export function parseInt(str: String, radix: i32 = 0): f64 {
  // @ts-ignore: string/String
  return parse<f64>(str, radix);
 }
 export function parseI32(str: String, radix: i32 = 0): i32 {
  // @ts-ignore: string/String
  return parse<i32>(str, radix);
 }
 export function parseI64(str: String, radix: i32 = 0): i64 {
  // @ts-ignore: string/String
  return parse<i64>(str, radix);
 }
--- a/std/assembly/symbol.ts
+++ b/std/assembly/symbol.ts
@ -4,6 +4,7 @@ import { Map } from "./map";
@lazy var idToString: Map<usize, string>;
@lazy var nextId: usize = 12; // Symbol.unscopables + 1
 // @ts-ignore: nolib
@unmanaged export class symbol {
  toString(): string {
    var id = changetype<usize>(this);
@ -52,6 +53,7 @@ export namespace Symbol {
  @lazy export const unscopables        = changetype<symbol>(11);
  /* tslint:disable */// not valid TS
  // @ts-ignore: identifier
  export function for(key: string): symbol {
    if (!stringToId) { stringToId = new Map(); idToString = new Map(); }
    else if (stringToId.has(key)) return changetype<symbol>(stringToId.get(key));
--- a/std/assembly/typedarray.ts
+++ b/std/assembly/typedarray.ts
@ -6,6 +6,7 @@ function clampToByte(value: i32): i32 {
 }
 export class Int8Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<i8>();
  constructor(length: i32) {
@ -68,6 +69,7 @@ export class Int8Array extends ArrayBufferView {
 }
 export class Uint8Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();
  constructor(length: i32) {
@ -124,6 +126,7 @@ export class Uint8Array extends ArrayBufferView {
 }
 export class Uint8ClampedArray extends Uint8Array {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();
  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {
@ -174,6 +177,7 @@ export class Uint8ClampedArray extends Uint8Array {
 }
 export class Int16Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<i16>();
  constructor(length: i32) {
@ -236,6 +240,7 @@ export class Int16Array extends ArrayBufferView {
 }
 export class Uint16Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u16>();
  constructor(length: i32) {
@ -298,6 +303,7 @@ export class Uint16Array extends ArrayBufferView {
 }
 export class Int32Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<i32>();
  constructor(length: i32) {
@ -360,6 +366,7 @@ export class Int32Array extends ArrayBufferView {
 }
 export class Uint32Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u32>();
  constructor(length: i32) {
@ -422,6 +429,7 @@ export class Uint32Array extends ArrayBufferView {
 }
 export class Int64Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<i64>();
  constructor(length: i32) {
@ -484,6 +492,7 @@ export class Int64Array extends ArrayBufferView {
 }
 export class Uint64Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u64>();
  constructor(length: i32) {
@ -546,6 +555,7 @@ export class Uint64Array extends ArrayBufferView {
 }
 export class Float32Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<f32>();
  constructor(length: i32) {
@ -608,6 +618,7 @@ export class Float32Array extends ArrayBufferView {
 }
 export class Float64Array extends ArrayBufferView {
  // @ts-ignore: decorator
  @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<f64>();
  constructor(length: i32) {
@ -669,6 +680,7 @@ export class Float64Array extends ArrayBufferView {
  }
 }
 // @ts-ignore: decorator
@inline function FILL<TArray extends ArrayBufferView, T extends number>(
  array: TArray,
  value: native<T>,
@ -689,6 +701,7 @@ export class Float64Array extends ArrayBufferView {
  return array;
 }
 // @ts-ignore: decorator
@inline function SORT<TArray extends ArrayBufferView, T>(
  array: TArray,
  comparator: (a: T, b: T) => i32
@ -709,6 +722,7 @@ export class Float64Array extends ArrayBufferView {
  return array;
 }
 // @ts-ignore: decorator
@inline function SUBARRAY<TArray extends ArrayBufferView, T>(
  array: TArray,
  begin: i32,
@ -728,6 +742,7 @@ export class Float64Array extends ArrayBufferView {
  return changetype<TArray>(out);
 }
 // @ts-ignore: decorator
@inline function REDUCE<TArray extends ArrayBufferView, T, TRet>(
  array: TArray,
  callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
@ -740,6 +755,7 @@ export class Float64Array extends ArrayBufferView {
  return initialValue;
 }
 // @ts-ignore: decorator
@inline function REDUCE_RIGHT<TArray extends ArrayBufferView, T, TRet>(
  array: TArray,
  callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
@ -752,6 +768,7 @@ export class Float64Array extends ArrayBufferView {
  return initialValue;
 }
 // @ts-ignore: decorator
@inline function MAP<TArray extends ArrayBufferView, T>(
  array: TArray,
  callbackfn: (value: T, index: i32, self: TArray) => T,
@ -769,6 +786,7 @@ export class Float64Array extends ArrayBufferView {
  return out;
 }
 // @ts-ignore: decorator
@inline function FIND_INDEX<TArray extends ArrayBufferView, T>(
  array: TArray,
  callbackfn: (value: T, index: i32, array: TArray) => bool,
@ -780,6 +798,7 @@ export class Float64Array extends ArrayBufferView {
  return -1;
 }
 // @ts-ignore: decorator
@inline function SOME<TArray extends ArrayBufferView, T>(
  array: TArray,
  callbackfn: (value: T, index: i32, array: TArray) => bool,
@ -791,6 +810,7 @@ export class Float64Array extends ArrayBufferView {
  return false;
 }
 // @ts-ignore: decorator
@inline function EVERY<TArray extends ArrayBufferView, T>(
  array: TArray,
  callbackfn: (value: T, index: i32, array: TArray) => bool,
@ -803,6 +823,7 @@ export class Float64Array extends ArrayBufferView {
  return true;
 }
 // @ts-ignore: decorator
@inline function FOREACH<TArray extends ArrayBufferView, T>(
  array: TArray,
  callbackfn: (value: T, index: i32, array: TArray) => void,
--- a/std/assembly/util/allocator.ts
+++ b/std/assembly/util/allocator.ts
@ -1,8 +1,15 @@
 /** Number of alignment bits. */
 // @ts-ignore: decorator
@inline export const AL_BITS: u32 = 3;
 /** Number of possible alignment values. */
 // @ts-ignore: decorator
@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;
 /** Mask to obtain just the alignment bits. */
 // @ts-ignore: decorator
@inline export const AL_MASK: usize = AL_SIZE - 1;
 /** Maximum 32-bit allocation size. */
 // @ts-ignore: decorator
@inline export const MAX_SIZE_32: usize = 1 << 30; // 1GB
--- a/std/assembly/util/hash.ts
+++ b/std/assembly/util/hash.ts
@ -1,16 +1,24 @@
 // @ts-ignore: decorator
@inline export function HASH<T>(key: T): u32 {
  if (isString(key)) {
    // @ts-ignore: type
    return hashStr(key);
  } else if (isReference<T>()) {
    if (sizeof<T>() == 4) return hash32(changetype<u32>(key));
    if (sizeof<T>() == 8) return hash64(changetype<u64>(key));
  } else if (isFloat<T>()) {
    // @ts-ignore: type
    if (sizeof<T>() == 4) return hash32(reinterpret<u32>(key));
    // @ts-ignore: type
    if (sizeof<T>() == 8) return hash64(reinterpret<u64>(key));
  } else {
    // @ts-ignore: type
    if (sizeof<T>() == 1) return hash8 (<u32>key);
    // @ts-ignore: type
    if (sizeof<T>() == 2) return hash16(<u32>key);
    // @ts-ignore: type
    if (sizeof<T>() == 4) return hash32(<u32>key);
    // @ts-ignore: type
    if (sizeof<T>() == 8) return hash64(<u64>key);
  }
  unreachable();
@ -18,7 +26,9 @@
 // FNV-1a 32-bit as a starting point, see: http://isthe.com/chongo/tech/comp/fnv/
 // @ts-ignore: decorator
@inline const FNV_OFFSET: u32 = 2166136261;
 // @ts-ignore: decorator
@inline const FNV_PRIME: u32 = 16777619;
 function hash8(key: u32): u32 {
--- a/std/assembly/util/number.ts
+++ b/std/assembly/util/number.ts
@ -1,8 +1,10 @@
 import { runtime } from "../runtime";
 import { CharCode } from "./string";
 // @ts-ignore: decorator
@inline export const MAX_DOUBLE_LENGTH = 28;
 // @ts-ignore: decorator
@lazy @inline const POWERS10: u32[] = [
  1,
  10,
@ -30,6 +32,7 @@ import { CharCode } from "./string";
  "80", "81", "82", "83", "84", "85", "86", "87", "88", "89",
  "90", "91", "92", "93", "94", "95", "96", "97", "98", "99"
 */
 // @ts-ignore: decorator
@lazy @inline const DIGITS: u32[] = [
  0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,
  0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,
@ -53,6 +56,7 @@ import { CharCode } from "./string";
  0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039
 ];
 // @ts-ignore: decorator
@lazy @inline const EXP_POWERS: i16[] = [
  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
   -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
@ -66,6 +70,7 @@ import { CharCode } from "./string";
 ];
 // 1e-348, 1e-340, ..., 1e340
 // @ts-ignore: decorator
@lazy @inline const FRC_POWERS: u64[] = [
  0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,
  0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,
--- a/std/assembly/util/sort.ts
+++ b/std/assembly/util/sort.ts
@ -1,45 +1,59 @@
 import { compareImpl } from "./string";
 // @ts-ignore: decorator
@inline export function COMPARATOR<T>(): (a: T, b: T) => i32 {
  if (isInteger<T>()) {
    if (isSigned<T>() && sizeof<T>() <= 4) {
      // @ts-ignore: type
      return (a: T, b: T): i32 => (<i32>(a - b));
    } else {
      // @ts-ignore: type
      return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
    }
  } else if (isFloat<T>()) {
    if (sizeof<T>() == 4) {
      return (a: T, b: T): i32 => {
        // @ts-ignore: type
        var ia = reinterpret<i32>(a);
        // @ts-ignore: type
        var ib = reinterpret<i32>(b);
        ia ^= (ia >> 31) >>> 1;
        ib ^= (ib >> 31) >>> 1;
        // @ts-ignore: type
        return <i32>(ia > ib) - <i32>(ia < ib);
      };
    } else {
      return (a: T, b: T): i32 => {
        // @ts-ignore: type
        var ia = reinterpret<i64>(a);
        // @ts-ignore: type
        var ib = reinterpret<i64>(b);
        ia ^= (ia >> 63) >>> 1;
        ib ^= (ib >> 63) >>> 1;
        // @ts-ignore: type
        return <i32>(ia > ib) - <i32>(ia < ib);
      };
    }
  } else if (isString<T>()) {
    return (a: T, b: T): i32 => {
      if (a === b || a === null || b === null) return 0;
      // @ts-ignore: type
      var alen = (<string>a).length;
      // @ts-ignore: type
      var blen = (<string>b).length;
      if (!alen && !blen) return 0;
      if (!alen) return -1;
      if (!blen) return  1;
      // @ts-ignore: type
      return compareImpl(<string>a, 0, <string>b, 0, <usize>min(alen, blen));
    };
  } else {
    // @ts-ignore: type
    return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
  }
 }
 // @ts-ignore: decorator
@inline export function SORT<T>(
  dataStart: usize,
  length: i32,
--- a/std/assembly/util/string.ts
+++ b/std/assembly/util/string.ts
@ -8,6 +8,7 @@ export function compareImpl(str1: string, index1: usize, str2: string, index2: u
  return result;
 }
 // @ts-ignore: decorator
@inline export const enum CharCode {
  PLUS = 0x2B,
  MINUS = 0x2D,
@ -57,29 +58,35 @@ export function isWhiteSpaceOrLineTerminator(c: u16): bool {
 /** Parses a string to an integer (usually), using the specified radix. */
 export function parse<T>(str: string, radix: i32 = 0): T {
  var len: i32 = str.length;
  // @ts-ignore: type
  if (!len) return <T>NaN;
  var ptr = changetype<usize>(str) /* + HEAD -> offset */;
-  var code = <i32>load<u16>(ptr, HEADER_SIZE);
+  var code = <i32>load<u16>(ptr);
  // determine sign
  var sign: T;
  if (code == CharCode.MINUS) {
    // @ts-ignore: type
    if (!--len) return <T>NaN;
-    code = <i32>load<u16>(ptr += 2, HEADER_SIZE);
+    code = <i32>load<u16>(ptr += 2);
    // @ts-ignore: type
    sign = -1;
  } else if (code == CharCode.PLUS) {
    // @ts-ignore: type
    if (!--len) return <T>NaN;
-    code = <i32>load<u16>(ptr += 2, HEADER_SIZE);
+    code = <i32>load<u16>(ptr += 2);
    // @ts-ignore: type
    sign = 1;
  } else {
    // @ts-ignore: type
    sign = 1;
  }
  // determine radix
  if (!radix) {
    if (code == CharCode._0 && len > 2) {
-      switch (<i32>load<u16>(ptr + 2, HEADER_SIZE)) {
+      switch (<i32>load<u16>(ptr + 2)) {
        case CharCode.B:
        case CharCode.b: {
          ptr += 4; len -= 2;
@ -102,13 +109,15 @@ export function parse<T>(str: string, radix: i32 = 0): T {
      }
    } else radix = 10;
  } else if (radix < 2 || radix > 36) {
    // @ts-ignore: cast
    return <T>NaN;
  }
  // calculate value
  // @ts-ignore: type
  var num: T = 0;
  while (len--) {
-    code = <i32>load<u16>(ptr, HEADER_SIZE);
+    code = <i32>load<u16>(ptr);
    if (code >= CharCode._0 && code <= CharCode._9) {
      code -= CharCode._0;
    } else if (code >= CharCode.A && code <= CharCode.Z) {
@ -117,8 +126,10 @@ export function parse<T>(str: string, radix: i32 = 0): T {
      code -= CharCode.a - 10;
    } else break;
    if (code >= radix) break;
    // @ts-ignore: type
    num = (num * radix) + code;
    ptr += 2;
  }
  // @ts-ignore: type
  return sign * num;
 }