From c950631b5ed897950b84630c6aadfd7da513f0b8 Mon Sep 17 00:00:00 2001
From: Daniel Ledda <ledda@cip.ifi.lmu.de>
Date: Sat, 3 Jul 2021 20:00:13 +0200
Subject: [PATCH] It all works....

---
 .gitignore                                    |    4 +
 .idea/workspace.xml                           |  218 +-
 package-lock.json                             | 2601 ++++++++
 package.json                                  |   24 +-
 public/index.html                             |    2 +-
 public/resources/3x3x4.png                    |  Bin 0 -> 44916 bytes
 public/resources/ColorWheel.png               |  Bin 0 -> 75404 bytes
 public/solver/SomaSolver.js                   |  138 -
 public/solver/false                           |    1 +
 public/solver/main.js                         |  461 +-
 public/solver/main.wasm                       |  Bin 14547 -> 12460 bytes
 public/solver/main.wat                        | 5644 +++++++++++++++++
 src/SomaSolution.ts                           |   41 +-
 src/SomaSolver.ts                             |   53 -
 src/{VoxelSpace.ts => VoxelSpaceBigInt.ts}    |  145 +-
 src/VoxelSpaceBoolean.ts                      |  366 ++
 src/desktop/build.js                          |    0
 src/desktop/main.js                           |   30 +
 src/desktop/preload.js                        |   12 +
 .../solver => src/solver/js}/SomaSolution.js  |   40 +-
 src/solver/js/SomaSolution.ts                 |  119 +
 src/solver/js/SomaSolver.js                   |   60 +
 src/solver/js/SomaSolver.ts                   |   73 +
 .../solver/js/VoxelSpaceBoolean.js            |  198 +-
 src/solver/js/VoxelSpaceBoolean.ts            |  364 ++
 src/solver/js/main.js                         |   16 +
 src/solver/js/main.ts                         |   18 +
 src/solver/js/package.json                    |   11 +
 src/solver/{ => wasm}/asconfig.json           |    4 +-
 .../{ => wasm}/assembly/SomaSolution.ts       |   22 +-
 src/solver/{ => wasm}/assembly/SomaSolver.ts  |   28 +-
 src/solver/{ => wasm}/assembly/VoxelSpace.ts  |  142 +-
 src/solver/{ => wasm}/assembly/index.ts       |    6 +-
 src/solver/{ => wasm}/assembly/tsconfig.json  |    0
 src/solver/{ => wasm}/index.js                |    2 +-
 src/solver/{ => wasm}/package-lock.json       |    0
 src/solver/{ => wasm}/package.json            |    4 +-
 src/store.ts                                  |  318 +-
 src/ui/CubeInput.svelte                       |   75 +-
 src/ui/Sidebar.svelte                         |  111 +-
 src/ui/Solution2D.svelte                      |   17 +-
 src/ui/SolutionViewer.svelte                  |   31 +-
 src/ui/threedee/PolycubeMesh.ts               |   23 +-
 src/ui/threedee/PolycubeScene.ts              |   16 +-
 tsconfig.json                                 |    2 +-
 45 files changed, 10537 insertions(+), 903 deletions(-)
 create mode 100644 public/resources/3x3x4.png
 create mode 100644 public/resources/ColorWheel.png
 delete mode 100644 public/solver/SomaSolver.js
 create mode 100644 public/solver/false
 create mode 100644 public/solver/main.wat
 delete mode 100644 src/SomaSolver.ts
 rename src/{VoxelSpace.ts => VoxelSpaceBigInt.ts} (65%)
 create mode 100644 src/VoxelSpaceBoolean.ts
 create mode 100644 src/desktop/build.js
 create mode 100644 src/desktop/main.js
 create mode 100644 src/desktop/preload.js
 rename {public/solver => src/solver/js}/SomaSolution.js (69%)
 create mode 100644 src/solver/js/SomaSolution.ts
 create mode 100644 src/solver/js/SomaSolver.js
 create mode 100644 src/solver/js/SomaSolver.ts
 rename public/solver/VoxelSpace.js => src/solver/js/VoxelSpaceBoolean.js (52%)
 create mode 100644 src/solver/js/VoxelSpaceBoolean.ts
 create mode 100644 src/solver/js/main.js
 create mode 100644 src/solver/js/main.ts
 create mode 100644 src/solver/js/package.json
 rename src/solver/{ => wasm}/asconfig.json (75%)
 rename src/solver/{ => wasm}/assembly/SomaSolution.ts (86%)
 rename src/solver/{ => wasm}/assembly/SomaSolver.ts (67%)
 rename src/solver/{ => wasm}/assembly/VoxelSpace.ts (67%)
 rename src/solver/{ => wasm}/assembly/index.ts (72%)
 rename src/solver/{ => wasm}/assembly/tsconfig.json (100%)
 rename src/solver/{ => wasm}/index.js (94%)
 rename src/solver/{ => wasm}/package-lock.json (100%)
 rename src/solver/{ => wasm}/package.json (57%)

diff --git a/.gitignore b/.gitignore
index 6e08204..e984720 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,7 @@
 /.vscode
 /.idea
 /src/solver/node_modules/
+/desktop-dist
+/**/node_modules
+/src/solver/wasm/build
+out/
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index e85d18a..244265c 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -1,59 +1,65 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="BranchesTreeState">
+    <expand>
+      <path>
+        <item name="ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="LOCAL_ROOT" type="e8cecc67:BranchNodeDescriptor" />
+      </path>
+      <path>
+        <item name="ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="REMOTE_ROOT" type="e8cecc67:BranchNodeDescriptor" />
+      </path>
+      <path>
+        <item name="ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="REMOTE_ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="GROUP_NODE:origin" type="e8cecc67:BranchNodeDescriptor" />
+      </path>
+    </expand>
+    <select>
+      <path>
+        <item name="ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="LOCAL_ROOT" type="e8cecc67:BranchNodeDescriptor" />
+        <item name="BRANCH:master" type="e8cecc67:BranchNodeDescriptor" />
+      </path>
+    </select>
+  </component>
   <component name="ChangeListManager">
     <list default="true" id="70635ef7-86ab-4681-b98d-dc8e4999995b" name="Default Changelist" comment="">
-      <change afterPath="$PROJECT_DIR$/public/solver/as-bind.esm.js" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/public/solver/main.wasm" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/SomaSolver.ts" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/solver/assembly/SomaSolution.ts" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/solver/assembly/VoxelSpace.ts" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/ui/Interactor.svelte" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/ui/Solution2D.svelte" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/ui/SolutionList.svelte" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/ui/threedee/GeometryManager.ts" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/ui/threedee/PolycubeMesh.ts" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/ui/threedee/PolycubeScene.ts" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/desktop/build.js" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/desktop/main.js" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/desktop/preload.js" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/solver/js/SomaSolver.ts" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/solver/js/VoxelSpaceBoolean.ts" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.gitignore" beforeDir="false" afterPath="$PROJECT_DIR$/.gitignore" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/package-lock.json" beforeDir="false" afterPath="$PROJECT_DIR$/package-lock.json" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/package.json" beforeDir="false" afterPath="$PROJECT_DIR$/package.json" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/global.css" beforeDir="false" afterPath="$PROJECT_DIR$/public/global.css" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/public/index.html" beforeDir="false" afterPath="$PROJECT_DIR$/public/index.html" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/000000.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/000001.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/000001.obj" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/none.obj" beforeDir="false" afterPath="$PROJECT_DIR$/public/resources/c000000.obj" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/x.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/x.obj" beforeDir="false" afterPath="$PROJECT_DIR$/public/resources/c000001.obj" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xy.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xy.obj" beforeDir="false" afterPath="$PROJECT_DIR$/public/resources/c000011.obj" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xymx.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xymx.obj" beforeDir="false" afterPath="$PROJECT_DIR$/public/resources/c001011.obj" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xymxmy.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xymxmy.obj" beforeDir="false" afterPath="$PROJECT_DIR$/public/resources/c011011.obj" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xyz.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xyz.obj" beforeDir="false" afterPath="$PROJECT_DIR$/public/resources/c000111.obj" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xyzmx.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel-cube/xyzmx.obj" beforeDir="false" afterPath="$PROJECT_DIR$/public/resources/c001111.obj" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel_cube.mtl" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/resources/bevel_cube.obj" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/public/solver/SomaSolver.js" beforeDir="false" afterPath="$PROJECT_DIR$/public/solver/SomaSolver.js" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/public/solver/SomaSolution.js" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/js/SomaSolution.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/public/solver/SomaSolver.js" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/public/solver/VoxelSpace.js" beforeDir="false" />
       <change beforePath="$PROJECT_DIR$/public/solver/main.js" beforeDir="false" afterPath="$PROJECT_DIR$/public/solver/main.js" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/App.svelte" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/App.svelte" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/CubeInput.svelte" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/CubeInput.svelte" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/OBJLoader.js" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/Polycube3D.svelte" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/SolutionViewer.svelte" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/PolycubeScene.ts" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/RotationControl.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/threedee/RotationControl.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/Sidebar.svelte" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/Sidebar.svelte" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/SolutionInteractor.svelte" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/SolutionList.svelte" beforeDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/main.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/main.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/solver/SomaSolution.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/SomaSolution.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/solver/SomaSolver.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/assembly/SomaSolver.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/solver/VoxelSpace.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/VoxelSpace.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/solver/main.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/assembly/index.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/public/solver/main.wasm" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/SomaSolution.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/SomaSolution.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/SomaSolver.ts" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/VoxelSpace.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/VoxelSpaceBigInt.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/asconfig.json" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/asconfig.json" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/assembly/SomaSolution.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/assembly/SomaSolution.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/assembly/SomaSolver.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/assembly/SomaSolver.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/assembly/VoxelSpace.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/assembly/VoxelSpace.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/assembly/index.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/assembly/index.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/assembly/tsconfig.json" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/assembly/tsconfig.json" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/index.js" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/index.js" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/package-lock.json" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/package-lock.json" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/solver/package.json" beforeDir="false" afterPath="$PROJECT_DIR$/src/solver/wasm/package.json" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/store.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/store.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/ui/CubeInput.svelte" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/CubeInput.svelte" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/ui/Sidebar.svelte" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/Sidebar.svelte" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/ui/Solution2D.svelte" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/Solution2D.svelte" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/ui/SolutionViewer.svelte" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/SolutionViewer.svelte" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/ui/threedee/PolycubeMesh.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/threedee/PolycubeMesh.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/ui/threedee/PolycubeScene.ts" beforeDir="false" afterPath="$PROJECT_DIR$/src/ui/threedee/PolycubeScene.ts" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/tsconfig.json" beforeDir="false" afterPath="$PROJECT_DIR$/tsconfig.json" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
@@ -64,13 +70,13 @@
   <component name="FileTemplateManagerImpl">
     <option name="RECENT_TEMPLATES">
       <list>
-        <option value="HTML File" />
         <option value="Sidebar" />
         <option value="SolutionInteractor" />
         <option value="CubeInput" />
         <option value="store.svelte" />
-        <option value="JavaScript File" />
         <option value="SolutionList.svelte" />
+        <option value="HTML File" />
+        <option value="JavaScript File" />
         <option value="TypeScript File" />
       </list>
     </option>
@@ -78,6 +84,11 @@
   <component name="Git.Settings">
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
   </component>
+  <component name="JsbtTreeLayoutManager">
+    <layout place="tools.popupGrunt">
+      <scroll-view-position x="0" y="0" />
+    </layout>
+  </component>
   <component name="ProjectId" id="1shUz7NMSUxY207ip64fWIgaebh" />
   <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
   <component name="ProjectViewState">
@@ -88,7 +99,7 @@
     <property name="DefaultHtmlFileTemplate" value="HTML File" />
     <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
     <property name="WebServerToolWindowFactoryState" value="false" />
-    <property name="last_opened_file_path" value="$PROJECT_DIR$/src/ui" />
+    <property name="last_opened_file_path" value="$PROJECT_DIR$/src/solver/js" />
     <property name="node.js.detected.package.eslint" value="true" />
     <property name="node.js.detected.package.tslint" value="true" />
     <property name="node.js.path.for.package.eslint" value="project" />
@@ -96,6 +107,7 @@
     <property name="node.js.selected.package.eslint" value="(autodetect)" />
     <property name="node.js.selected.package.tslint" value="(autodetect)" />
     <property name="nodejs_package_manager_path" value="npm" />
+    <property name="run.code.analysis.last.selected.profile" value="pProject Default" />
     <property name="settings.editor.selected.configurable" value="terminal" />
     <property name="ts.external.directory.path" value="$PROJECT_DIR$/node_modules/typescript/lib" />
     <property name="use.deno.dismiss" value="true" />
@@ -103,13 +115,15 @@
   </component>
   <component name="RecentsManager">
     <key name="MoveFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/public/solver" />
       <recent name="$PROJECT_DIR$/src" />
-      <recent name="$PROJECT_DIR$/src/ui" />
-      <recent name="$PROJECT_DIR$/src/solver" />
-      <recent name="$PROJECT_DIR$/src/ui/threedee" />
-      <recent name="$PROJECT_DIR$/src/webapp" />
+      <recent name="$PROJECT_DIR$/src/solver/js" />
+      <recent name="$PROJECT_DIR$/src/solver/wasm" />
+      <recent name="$PROJECT_DIR$/resources/app" />
     </key>
     <key name="CopyFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/src/solver/js" />
+      <recent name="$PROJECT_DIR$/resources/app" />
       <recent name="$PROJECT_DIR$/src/ui" />
       <recent name="$PROJECT_DIR$/public/solver" />
       <recent name="$PROJECT_DIR$/src" />
@@ -147,6 +161,17 @@
       <workItem from="1622971349849" duration="20106000" />
       <workItem from="1623052849485" duration="37878000" />
       <workItem from="1623141089245" duration="24731000" />
+      <workItem from="1623261066851" duration="590000" />
+      <workItem from="1623485615537" duration="593000" />
+      <workItem from="1623668677088" duration="8416000" />
+      <workItem from="1623740877224" duration="26074000" />
+      <workItem from="1624715065692" duration="610000" />
+      <workItem from="1624802539718" duration="6683000" />
+      <workItem from="1624820040894" duration="7878000" />
+      <workItem from="1624862787465" duration="3754000" />
+      <workItem from="1624953370630" duration="10086000" />
+      <workItem from="1625293881668" duration="18235000" />
+      <workItem from="1625330866437" duration="2495000" />
     </task>
     <servers />
   </component>
@@ -154,25 +179,82 @@
     <option name="version" value="3" />
     <option name="exactExcludedFiles">
       <list>
-        <option value="$PROJECT_DIR$/src/solver/assembly/index.js" />
-        <option value="$PROJECT_DIR$/src/solver/assembly/SomaSolution.js" />
-        <option value="$PROJECT_DIR$/src/solver/assembly/SomaSolver.js" />
-        <option value="$PROJECT_DIR$/src/solver/assembly/VoxelSpace.js" />
-        <option value="$PROJECT_DIR$/src/solver/assembly/SomaSolution.js" />
-        <option value="$PROJECT_DIR$/src/solver/assembly/SomaSolver.js" />
-        <option value="$PROJECT_DIR$/src/solver/assembly/VoxelSpace.js" />
+        <option value="$PROJECT_DIR$/src/solver/js/SomaSolver.js" />
+        <option value="$PROJECT_DIR$/src/SomaSolution.js" />
+        <option value="$PROJECT_DIR$/src/SomaSolution.js" />
+        <option value="$PROJECT_DIR$/src/solver/js/SomaSolver.js" />
+        <option value="$PROJECT_DIR$/src/VoxelSpaceBigInt.js" />
+        <option value="$PROJECT_DIR$/src/VoxelSpaceBoolean.js" />
+        <option value="$PROJECT_DIR$/src/SomaSolution.js" />
+        <option value="$PROJECT_DIR$/src/VoxelSpaceBigInt.js" />
+        <option value="$PROJECT_DIR$/src/VoxelSpaceBoolean.js" />
+        <option value="$PROJECT_DIR$/src/SomaSolution.js" />
+        <option value="$PROJECT_DIR$/src/VoxelSpaceBigInt.js" />
+        <option value="$PROJECT_DIR$/src/VoxelSpaceBoolean.js" />
+        <option value="$PROJECT_DIR$/src/SomaSolution.js" />
+        <option value="$PROJECT_DIR$/src/solver/js/SomaSolver.js" />
+        <option value="$PROJECT_DIR$/src/VoxelSpaceBigInt.js" />
+        <option value="$PROJECT_DIR$/src/VoxelSpaceBoolean.js" />
+        <option value="$PROJECT_DIR$/src/SomaSolution.js" />
+        <option value="$PROJECT_DIR$/src/solver/js/VoxelSpaceBoolean.js" />
+        <option value="$PROJECT_DIR$/src/solver/js/SomaSolution.js" />
+        <option value="$PROJECT_DIR$/src/solver/js/SomaSolver.js" />
+        <option value="$PROJECT_DIR$/src/solver/js/main.js" />
       </list>
     </option>
   </component>
+  <component name="Vcs.Log.History.Properties">
+    <option name="COLUMN_ORDER">
+      <list>
+        <option value="0" />
+        <option value="2" />
+        <option value="3" />
+        <option value="1" />
+      </list>
+    </option>
+  </component>
+  <component name="Vcs.Log.Tabs.Properties">
+    <option name="TAB_STATES">
+      <map>
+        <entry key="MAIN">
+          <value>
+            <State>
+              <option name="FILTERS">
+                <map>
+                  <entry key="branch">
+                    <value>
+                      <list>
+                        <option value="master" />
+                      </list>
+                    </value>
+                  </entry>
+                </map>
+              </option>
+            </State>
+          </value>
+        </entry>
+      </map>
+    </option>
+    <option name="oldMeFiltersMigrated" value="true" />
+  </component>
   <component name="WindowStateProjectService">
-    <state x="633" y="342" width="643" height="403" key="#com.intellij.fileTypes.FileTypeChooser" timestamp="1623101908210">
+    <state x="633" y="342" width="643" height="403" key="#com.intellij.fileTypes.FileTypeChooser" timestamp="1623671479936">
       <screen x="0" y="27" width="1920" height="1053" />
     </state>
-    <state x="633" y="342" width="643" height="403" key="#com.intellij.fileTypes.FileTypeChooser/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1623101908210" />
-    <state x="643" y="194" width="614" height="706" key="#com.intellij.refactoring.rename.AutomaticRenamingDialog" timestamp="1621349929863">
-      <screen x="0" y="27" width="1920" height="1053" />
+    <state x="633" y="342" width="643" height="403" key="#com.intellij.fileTypes.FileTypeChooser/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1623671479936" />
+    <state x="692" y="20" width="1213" height="1060" key="#com.intellij.refactoring.rename.AutomaticRenamingDialog" timestamp="1625307697424">
+      <screen x="0" y="27" width="3840" height="1053" />
     </state>
+    <state x="692" y="20" width="1213" height="1060" key="#com.intellij.refactoring.rename.AutomaticRenamingDialog/0.27.3840.1053@0.27.3840.1053" timestamp="1625307697424" />
     <state x="643" y="194" width="614" height="706" key="#com.intellij.refactoring.rename.AutomaticRenamingDialog/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1621349929863" />
+    <state x="696" y="393" width="518" height="301" key="ANALYSIS_DLG_com.intellij.analysis.BaseAnalysisAction$1" timestamp="1624963157966">
+      <screen x="0" y="27" width="1920" height="1053" />
+    </state>
+    <state x="696" y="393" width="518" height="301" key="ANALYSIS_DLG_com.intellij.analysis.BaseAnalysisAction$1/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1624963157966" />
+    <state x="92" y="69" width="1720" height="880" key="DiffContextDialog" timestamp="1624822125389">
+      <screen x="0" y="27" width="1920" height="1053" />
+    </state>
+    <state x="92" y="69" width="1720" height="880" key="DiffContextDialog/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1624822125389" />
     <state x="743" y="301" width="716" height="623" key="FileChooserDialogImpl" timestamp="1621932819206">
       <screen x="0" y="27" width="1920" height="1053" />
     </state>
@@ -189,11 +271,15 @@
       <screen x="0" y="27" width="1920" height="1053" />
     </state>
     <state x="651" y="279" width="618" height="522" key="find.popup/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1623164695220" />
-    <state x="624" y="245" key="run.anything.popup" timestamp="1623150034896">
+    <state x="834" y="395" width="250" height="278" key="jetbrains.javascript.buildTools.run-task-popup" timestamp="1623671403065">
       <screen x="0" y="27" width="1920" height="1053" />
     </state>
-    <state x="1248" y="245" key="run.anything.popup/0.27.3840.1053@0.27.3840.1053" timestamp="1621713204008" />
-    <state x="624" y="245" key="run.anything.popup/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1623150034896" />
+    <state x="834" y="395" width="250" height="278" key="jetbrains.javascript.buildTools.run-task-popup/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1623671403065" />
+    <state x="1248" y="245" key="run.anything.popup" timestamp="1625305747628">
+      <screen x="0" y="27" width="3840" height="1053" />
+    </state>
+    <state x="1248" y="245" key="run.anything.popup/0.27.3840.1053@0.27.3840.1053" timestamp="1625305747628" />
+    <state x="624" y="245" key="run.anything.popup/1920.0.1920.1080/0.27.1920.1053@0.27.1920.1053" timestamp="1624805204463" />
     <state x="755" y="405" width="400" height="284" key="scopes" timestamp="1621932851405">
       <screen x="0" y="27" width="1920" height="1053" />
     </state>
diff --git a/package-lock.json b/package-lock.json
index 6000ff3..880484e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -4,6 +4,12 @@
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
+    "7zip-bin": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.1.1.tgz",
+      "integrity": "sha512-sAP4LldeWNz0lNzmTird3uWfFDWWTeg6V/MsmyyLR9X1idwKBWIgt/ZvinqQldJm3LecKEs1emkbquO6PCiLVQ==",
+      "dev": true
+    },
     "@babel/code-frame": {
       "version": "7.12.13",
       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.13.tgz",
@@ -82,6 +88,127 @@
         }
       }
     },
+    "@develar/schema-utils": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.6.5.tgz",
+      "integrity": "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig==",
+      "dev": true,
+      "requires": {
+        "ajv": "^6.12.0",
+        "ajv-keywords": "^3.4.1"
+      }
+    },
+    "@electron/get": {
+      "version": "1.12.4",
+      "resolved": "https://registry.npmjs.org/@electron/get/-/get-1.12.4.tgz",
+      "integrity": "sha512-6nr9DbJPUR9Xujw6zD3y+rS95TyItEVM0NVjt1EehY2vUWfIgPiIPVHxCvaTS0xr2B+DRxovYVKbuOWqC35kjg==",
+      "dev": true,
+      "requires": {
+        "debug": "^4.1.1",
+        "env-paths": "^2.2.0",
+        "fs-extra": "^8.1.0",
+        "global-agent": "^2.0.2",
+        "global-tunnel-ng": "^2.7.1",
+        "got": "^9.6.0",
+        "progress": "^2.0.3",
+        "semver": "^6.2.0",
+        "sumchecker": "^3.0.1"
+      }
+    },
+    "@electron/universal": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@electron/universal/-/universal-1.0.5.tgz",
+      "integrity": "sha512-zX9O6+jr2NMyAdSkwEUlyltiI4/EBLu2Ls/VD3pUQdi3cAYeYfdQnT2AJJ38HE4QxLccbU13LSpccw1IWlkyag==",
+      "dev": true,
+      "requires": {
+        "@malept/cross-spawn-promise": "^1.1.0",
+        "asar": "^3.0.3",
+        "debug": "^4.3.1",
+        "dir-compare": "^2.4.0",
+        "fs-extra": "^9.0.1"
+      },
+      "dependencies": {
+        "fs-extra": {
+          "version": "9.1.0",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+          "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+          "dev": true,
+          "requires": {
+            "at-least-node": "^1.0.0",
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "jsonfile": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+          "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.6",
+            "universalify": "^2.0.0"
+          }
+        },
+        "universalify": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+          "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+          "dev": true
+        }
+      }
+    },
+    "@malept/cross-spawn-promise": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-1.1.1.tgz",
+      "integrity": "sha512-RTBGWL5FWQcg9orDOCcp4LvItNzUPcyEU9bwaeJX0rJ1IQxzucC48Y0/sQLp/g6t99IQgAlGIaesJS+gTn7tVQ==",
+      "dev": true,
+      "requires": {
+        "cross-spawn": "^7.0.1"
+      }
+    },
+    "@malept/flatpak-bundler": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@malept/flatpak-bundler/-/flatpak-bundler-0.4.0.tgz",
+      "integrity": "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q==",
+      "dev": true,
+      "requires": {
+        "debug": "^4.1.1",
+        "fs-extra": "^9.0.0",
+        "lodash": "^4.17.15",
+        "tmp-promise": "^3.0.2"
+      },
+      "dependencies": {
+        "fs-extra": {
+          "version": "9.1.0",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+          "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+          "dev": true,
+          "requires": {
+            "at-least-node": "^1.0.0",
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "jsonfile": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+          "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.6",
+            "universalify": "^2.0.0"
+          }
+        },
+        "universalify": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+          "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+          "dev": true
+        }
+      }
+    },
     "@polka/url": {
       "version": "1.0.0-next.12",
       "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.12.tgz",
@@ -145,24 +272,92 @@
         }
       }
     },
+    "@sindresorhus/is": {
+      "version": "0.14.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz",
+      "integrity": "sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==",
+      "dev": true
+    },
+    "@szmarczak/http-timer": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-1.1.2.tgz",
+      "integrity": "sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==",
+      "dev": true,
+      "requires": {
+        "defer-to-connect": "^1.0.1"
+      }
+    },
     "@tsconfig/svelte": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/@tsconfig/svelte/-/svelte-1.0.10.tgz",
       "integrity": "sha512-EBrpH2iXXfaf/9z81koiDYkp2mlwW2XzFcAqn6qh7VKyP8zBvHHAQzNhY+W9vH5arAjmGAm5g8ElWq6YmXm3ig==",
       "dev": true
     },
+    "@types/debug": {
+      "version": "4.1.5",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.5.tgz",
+      "integrity": "sha512-Q1y515GcOdTHgagaVFhHnIFQ38ygs/kmxdNpvpou+raI9UO3YZcHDngBSYKQklcKlvA7iuQlmIKbzvmxcOE9CQ==",
+      "dev": true
+    },
     "@types/estree": {
       "version": "0.0.39",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz",
       "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==",
       "dev": true
     },
+    "@types/fs-extra": {
+      "version": "9.0.11",
+      "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.11.tgz",
+      "integrity": "sha512-mZsifGG4QeQ7hlkhO56u7zt/ycBgGxSVsFI/6lGTU34VtwkiqrrSDgw0+ygs8kFGWcXnFQWMrzF2h7TtDFNixA==",
+      "dev": true,
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "@types/glob": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.1.3.tgz",
+      "integrity": "sha512-SEYeGAIQIQX8NN6LDKprLjbrd5dARM5EXsd8GI/A5l0apYI1fGMWgPHSe4ZKL4eozlAyI+doUE9XbYS4xCkQ1w==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "@types/minimatch": "*",
+        "@types/node": "*"
+      }
+    },
+    "@types/minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-1z8k4wzFnNjVK/tlxvrWuK5WMt6mydWWP7+zvH5eFep4oj+UkrfiJTRtjCeBXNpwaA/FYqqtb4/QS4ianFpIRA==",
+      "dev": true,
+      "optional": true
+    },
     "@types/node": {
       "version": "15.6.0",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-15.6.0.tgz",
       "integrity": "sha512-gCYSfQpy+LYhOFTKAeE8BkyGqaxmlFxe+n4DKM6DR0wzw/HISUE/hAmkC/KT8Sw5PCJblqg062b3z9gucv3k0A==",
       "dev": true
     },
+    "@types/plist": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/plist/-/plist-3.0.2.tgz",
+      "integrity": "sha512-ULqvZNGMv0zRFvqn8/4LSPtnmN4MfhlPNtJCTpKuIIxGVGZ2rYWzFXrvEBoh9CVyqSE7D6YFRJ1hydLHI6kbWw==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "@types/node": "*",
+        "xmlbuilder": ">=11.0.1"
+      },
+      "dependencies": {
+        "xmlbuilder": {
+          "version": "15.1.1",
+          "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",
+          "integrity": "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==",
+          "dev": true,
+          "optional": true
+        }
+      }
+    },
     "@types/pug": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/@types/pug/-/pug-2.0.4.tgz",
@@ -193,6 +388,101 @@
       "integrity": "sha512-Jwq5XYUkzAcPTo34hlGAQGUyAI0b2F3aCCFWG/v7ZhJBEG5HGcusMSr70GhDlT8Gs0f02QnSPZ2RCA1MrCOa/w==",
       "dev": true
     },
+    "@types/verror": {
+      "version": "1.10.4",
+      "resolved": "https://registry.npmjs.org/@types/verror/-/verror-1.10.4.tgz",
+      "integrity": "sha512-OjJdqx6QlbyZw9LShPwRW+Kmiegeg3eWNI41MQQKaG3vjdU2L9SRElntM51HmHBY1cu7izxQJ1lMYioQh3XMBg==",
+      "dev": true,
+      "optional": true
+    },
+    "@types/yargs": {
+      "version": "16.0.3",
+      "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.3.tgz",
+      "integrity": "sha512-YlFfTGS+zqCgXuXNV26rOIeETOkXnGQXP/pjjL9P0gO/EP9jTmc7pUBhx+jVEIxpq41RX33GQ7N3DzOSfZoglQ==",
+      "dev": true,
+      "requires": {
+        "@types/yargs-parser": "*"
+      }
+    },
+    "@types/yargs-parser": {
+      "version": "20.2.0",
+      "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-20.2.0.tgz",
+      "integrity": "sha512-37RSHht+gzzgYeobbG+KWryeAW8J33Nhr69cjTqSYymXVZEN9NbRYWoYlRtDhHKPVT1FyNKwaTPC1NynKZpzRA==",
+      "dev": true
+    },
+    "ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dev": true,
+      "requires": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      }
+    },
+    "ajv-keywords": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+      "dev": true
+    },
+    "ansi-align": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.0.tgz",
+      "integrity": "sha512-ZpClVKqXN3RGBmKibdfWzqCY4lnjEuoNzU5T0oEFpfd/z5qJHVarukridD4juLO2FXMiwUQxr9WqQtaYa8XRYw==",
+      "dev": true,
+      "requires": {
+        "string-width": "^3.0.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+          "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+          "dev": true
+        },
+        "emoji-regex": {
+          "version": "7.0.3",
+          "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+          "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
+          "dev": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+          "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^4.1.0"
+          }
+        }
+      }
+    },
+    "ansi-regex": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz",
+      "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==",
+      "dev": true
+    },
     "ansi-styles": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
@@ -212,6 +502,111 @@
         "picomatch": "^2.0.4"
       }
     },
+    "app-builder-bin": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-3.5.13.tgz",
+      "integrity": "sha512-ighVe9G+bT1ENGdp9ecO1P+94vv/f+FUwaI+XkNzeg9bYF8Oi3BQ+mJuxS00UgyHs8luuOzjzC+qnAtdb43Mpg==",
+      "dev": true
+    },
+    "app-builder-lib": {
+      "version": "22.11.7",
+      "resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-22.11.7.tgz",
+      "integrity": "sha512-pS9/cR4/TnNZVAHZECiSvvwTBzbwblj7KBBZkMKDG57nibq0I1XY8zAaYeHFdlYTyrRcz9JUXbAqJKezya7UFQ==",
+      "dev": true,
+      "requires": {
+        "7zip-bin": "~5.1.1",
+        "@develar/schema-utils": "~2.6.5",
+        "@electron/universal": "1.0.5",
+        "@malept/flatpak-bundler": "^0.4.0",
+        "async-exit-hook": "^2.0.1",
+        "bluebird-lst": "^1.0.9",
+        "builder-util": "22.11.7",
+        "builder-util-runtime": "8.7.7",
+        "chromium-pickle-js": "^0.2.0",
+        "debug": "^4.3.2",
+        "ejs": "^3.1.6",
+        "electron-publish": "22.11.7",
+        "fs-extra": "^10.0.0",
+        "hosted-git-info": "^4.0.2",
+        "is-ci": "^3.0.0",
+        "isbinaryfile": "^4.0.8",
+        "js-yaml": "^4.1.0",
+        "lazy-val": "^1.0.5",
+        "minimatch": "^3.0.4",
+        "read-config-file": "6.2.0",
+        "sanitize-filename": "^1.6.3",
+        "semver": "^7.3.5",
+        "temp-file": "^3.4.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.2",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
+          "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
+          "dev": true,
+          "requires": {
+            "ms": "2.1.2"
+          }
+        },
+        "fs-extra": {
+          "version": "10.0.0",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.0.0.tgz",
+          "integrity": "sha512-C5owb14u9eJwizKGdchcDUQeFtlSHHthBk8pbX9Vc1PFZrLombudjDnNns88aYslCyF6IY5SUw3Roz6xShcEIQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "hosted-git-info": {
+          "version": "4.0.2",
+          "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.0.2.tgz",
+          "integrity": "sha512-c9OGXbZ3guC/xOlCg1Ci/VgWlwsqDv1yMQL1CWqXDL0hDjXuNcq0zuR4xqPSuasI3kqFDhqSyTjREz5gzq0fXg==",
+          "dev": true,
+          "requires": {
+            "lru-cache": "^6.0.0"
+          }
+        },
+        "isbinaryfile": {
+          "version": "4.0.8",
+          "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.8.tgz",
+          "integrity": "sha512-53h6XFniq77YdW+spoRrebh0mnmTxRPTlcuIArO57lmMdq4uBKFKaeTjnb92oYWrSn/LVL+LT+Hap2tFQj8V+w==",
+          "dev": true
+        },
+        "jsonfile": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+          "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.6",
+            "universalify": "^2.0.0"
+          }
+        },
+        "semver": {
+          "version": "7.3.5",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz",
+          "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==",
+          "dev": true,
+          "requires": {
+            "lru-cache": "^6.0.0"
+          }
+        },
+        "universalify": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+          "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+          "dev": true
+        }
+      }
+    },
+    "argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true
+    },
     "as-bind": {
       "version": "0.7.1",
       "resolved": "https://registry.npmjs.org/as-bind/-/as-bind-0.7.1.tgz",
@@ -220,18 +615,140 @@
         "visitor-as": "^0.5.0"
       }
     },
+    "asar": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/asar/-/asar-3.0.3.tgz",
+      "integrity": "sha512-k7zd+KoR+n8pl71PvgElcoKHrVNiSXtw7odKbyNpmgKe7EGRF9Pnu3uLOukD37EvavKwVFxOUpqXTIZC5B5Pmw==",
+      "dev": true,
+      "requires": {
+        "@types/glob": "^7.1.1",
+        "chromium-pickle-js": "^0.2.0",
+        "commander": "^5.0.0",
+        "glob": "^7.1.6",
+        "minimatch": "^3.0.4"
+      },
+      "dependencies": {
+        "commander": {
+          "version": "5.1.0",
+          "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
+          "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+          "dev": true
+        }
+      }
+    },
+    "assert-plus": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz",
+      "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=",
+      "dev": true,
+      "optional": true
+    },
+    "async": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/async/-/async-0.9.2.tgz",
+      "integrity": "sha1-rqdNXmHB+JlhO/ZL2mbUx48v0X0=",
+      "dev": true
+    },
+    "async-exit-hook": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/async-exit-hook/-/async-exit-hook-2.0.1.tgz",
+      "integrity": "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw==",
+      "dev": true
+    },
+    "at-least-node": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
+      "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",
+      "dev": true
+    },
     "balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
       "dev": true
     },
+    "base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "dev": true,
+      "optional": true
+    },
     "binary-extensions": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
       "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
       "dev": true
     },
+    "bluebird": {
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz",
+      "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==",
+      "dev": true
+    },
+    "bluebird-lst": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/bluebird-lst/-/bluebird-lst-1.0.9.tgz",
+      "integrity": "sha512-7B1Rtx82hjnSD4PGLAjVWeYH3tHAcVUmChh85a3lltKQm6FresXh9ErQo6oAv6CqxttczC3/kEg8SY5NluPuUw==",
+      "dev": true,
+      "requires": {
+        "bluebird": "^3.5.5"
+      }
+    },
+    "boolean": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.1.2.tgz",
+      "integrity": "sha512-YN6UmV0FfLlBVvRvNPx3pz5W/mUoYB24J4WSXOKP/OOJpi+Oq6WYqPaNTHzjI0QzwWtnvEd5CGYyQPgp1jFxnw==",
+      "dev": true,
+      "optional": true
+    },
+    "boxen": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/boxen/-/boxen-5.0.1.tgz",
+      "integrity": "sha512-49VBlw+PrWEF51aCmy7QIteYPIFZxSpvqBdP/2itCPPlJ49kj9zg/XPRFrdkne2W+CfwXUls8exMvu1RysZpKA==",
+      "dev": true,
+      "requires": {
+        "ansi-align": "^3.0.0",
+        "camelcase": "^6.2.0",
+        "chalk": "^4.1.0",
+        "cli-boxes": "^2.2.1",
+        "string-width": "^4.2.0",
+        "type-fest": "^0.20.2",
+        "widest-line": "^3.1.0",
+        "wrap-ansi": "^7.0.0"
+      },
+      "dependencies": {
+        "camelcase": {
+          "version": "6.2.0",
+          "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.2.0.tgz",
+          "integrity": "sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==",
+          "dev": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+          "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "4.2.2",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz",
+          "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.0"
+          }
+        },
+        "type-fest": {
+          "version": "0.20.2",
+          "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+          "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+          "dev": true
+        }
+      }
+    },
     "brace-expansion": {
       "version": "1.1.11",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
@@ -251,17 +768,153 @@
         "fill-range": "^7.0.1"
       }
     },
+    "buffer": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.1.13"
+      }
+    },
+    "buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=",
+      "dev": true
+    },
+    "buffer-equal": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/buffer-equal/-/buffer-equal-1.0.0.tgz",
+      "integrity": "sha1-WWFrSYME1Var1GaWayLu2j7KX74=",
+      "dev": true
+    },
     "buffer-from": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
       "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A=="
     },
+    "builder-util": {
+      "version": "22.11.7",
+      "resolved": "https://registry.npmjs.org/builder-util/-/builder-util-22.11.7.tgz",
+      "integrity": "sha512-ihqUe5ey82LM9qqQe0/oIcaSm9w+B9UjcsWJZxJliTBsbU+sErOpDFpHW+sim0veiTF/EIcGUh9HoduWw+l9FA==",
+      "dev": true,
+      "requires": {
+        "7zip-bin": "~5.1.1",
+        "@types/debug": "^4.1.5",
+        "@types/fs-extra": "^9.0.11",
+        "app-builder-bin": "3.5.13",
+        "bluebird-lst": "^1.0.9",
+        "builder-util-runtime": "8.7.7",
+        "chalk": "^4.1.1",
+        "debug": "^4.3.2",
+        "fs-extra": "^10.0.0",
+        "is-ci": "^3.0.0",
+        "js-yaml": "^4.1.0",
+        "source-map-support": "^0.5.19",
+        "stat-mode": "^1.0.0",
+        "temp-file": "^3.4.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.2",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
+          "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
+          "dev": true,
+          "requires": {
+            "ms": "2.1.2"
+          }
+        },
+        "fs-extra": {
+          "version": "10.0.0",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.0.0.tgz",
+          "integrity": "sha512-C5owb14u9eJwizKGdchcDUQeFtlSHHthBk8pbX9Vc1PFZrLombudjDnNns88aYslCyF6IY5SUw3Roz6xShcEIQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "jsonfile": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+          "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.6",
+            "universalify": "^2.0.0"
+          }
+        },
+        "universalify": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+          "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+          "dev": true
+        }
+      }
+    },
+    "builder-util-runtime": {
+      "version": "8.7.7",
+      "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-8.7.7.tgz",
+      "integrity": "sha512-RUfoXzVrmFFI0K/Oft0CtP1LpTIOlBeLJatt5DePTI0KlxE156am4SGUpqtbbdqZNm++LkV9mX4olBDcXyGPow==",
+      "dev": true,
+      "requires": {
+        "debug": "^4.3.2",
+        "sax": "^1.2.4"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.2",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
+          "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
+          "dev": true,
+          "requires": {
+            "ms": "2.1.2"
+          }
+        }
+      }
+    },
     "builtin-modules": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.2.0.tgz",
       "integrity": "sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==",
       "dev": true
     },
+    "cacheable-request": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-6.1.0.tgz",
+      "integrity": "sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==",
+      "dev": true,
+      "requires": {
+        "clone-response": "^1.0.2",
+        "get-stream": "^5.1.0",
+        "http-cache-semantics": "^4.0.0",
+        "keyv": "^3.0.0",
+        "lowercase-keys": "^2.0.0",
+        "normalize-url": "^4.1.0",
+        "responselike": "^1.0.2"
+      },
+      "dependencies": {
+        "get-stream": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+          "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+          "dev": true,
+          "requires": {
+            "pump": "^3.0.0"
+          }
+        },
+        "lowercase-keys": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz",
+          "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==",
+          "dev": true
+        }
+      }
+    },
     "callsites": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
@@ -294,6 +947,111 @@
         "readdirp": "~3.5.0"
       }
     },
+    "chromium-pickle-js": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/chromium-pickle-js/-/chromium-pickle-js-0.2.0.tgz",
+      "integrity": "sha1-BKEGZywYsIWrd02YPfo+oTjyIgU=",
+      "dev": true
+    },
+    "ci-info": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.2.0.tgz",
+      "integrity": "sha512-dVqRX7fLUm8J6FgHJ418XuIgDLZDkYcDFTeL6TA2gt5WlIZUQrrH6EZrNClwT/H0FateUsZkGIOPRrLbP+PR9A==",
+      "dev": true
+    },
+    "cli-boxes": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-2.2.1.tgz",
+      "integrity": "sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==",
+      "dev": true
+    },
+    "cli-truncate": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-1.1.0.tgz",
+      "integrity": "sha512-bAtZo0u82gCfaAGfSNxUdTI9mNyza7D8w4CVCcaOsy7sgwDzvx6ekr6cuWJqY3UGzgnQ1+4wgENup5eIhgxEYA==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "slice-ansi": "^1.0.0",
+        "string-width": "^2.0.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
+          "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
+          "dev": true,
+          "optional": true
+        },
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true,
+          "optional": true
+        },
+        "string-width": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
+          "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^4.0.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
+          "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "ansi-regex": "^3.0.0"
+          }
+        }
+      }
+    },
+    "cliui": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
+      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
+      "dev": true,
+      "requires": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^7.0.0"
+      },
+      "dependencies": {
+        "is-fullwidth-code-point": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+          "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "4.2.2",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz",
+          "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.0"
+          }
+        }
+      }
+    },
+    "clone-response": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.2.tgz",
+      "integrity": "sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws=",
+      "dev": true,
+      "requires": {
+        "mimic-response": "^1.0.0"
+      }
+    },
     "color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -327,23 +1085,583 @@
       "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
       "dev": true
     },
+    "concat-stream": {
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz",
+      "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
+      "dev": true,
+      "requires": {
+        "buffer-from": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^2.2.2",
+        "typedarray": "^0.0.6"
+      }
+    },
+    "config-chain": {
+      "version": "1.1.13",
+      "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz",
+      "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "ini": "^1.3.4",
+        "proto-list": "~1.2.1"
+      }
+    },
+    "configstore": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/configstore/-/configstore-5.0.1.tgz",
+      "integrity": "sha512-aMKprgk5YhBNyH25hj8wGt2+D52Sw1DRRIzqBwLp2Ya9mFmY8KPvvtvmna8SxVR9JMZ4kzMD68N22vlaRpkeFA==",
+      "dev": true,
+      "requires": {
+        "dot-prop": "^5.2.0",
+        "graceful-fs": "^4.1.2",
+        "make-dir": "^3.0.0",
+        "unique-string": "^2.0.0",
+        "write-file-atomic": "^3.0.0",
+        "xdg-basedir": "^4.0.0"
+      }
+    },
     "console-clear": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/console-clear/-/console-clear-1.1.1.tgz",
       "integrity": "sha512-pMD+MVR538ipqkG5JXeOEbKWS5um1H4LUUccUQG68qpeqBYbzYy79Gh55jkd2TtPdRfUaLWdv6LPP//5Zt0aPQ=="
     },
+    "core-js": {
+      "version": "3.14.0",
+      "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.14.0.tgz",
+      "integrity": "sha512-3s+ed8er9ahK+zJpp9ZtuVcDoFzHNiZsPbNAAE4KXgrRHbjSqqNN6xGSXq6bq7TZIbKj4NLrLb6bJ5i+vSVjHA==",
+      "dev": true,
+      "optional": true
+    },
+    "core-util-is": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
+      "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
+      "dev": true
+    },
+    "crc": {
+      "version": "3.8.0",
+      "resolved": "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz",
+      "integrity": "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "buffer": "^5.1.0"
+      }
+    },
+    "cross-spawn": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
+      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+      "dev": true,
+      "requires": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      }
+    },
+    "crypto-random-string": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz",
+      "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==",
+      "dev": true
+    },
+    "cuint": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/cuint/-/cuint-0.2.2.tgz",
+      "integrity": "sha1-QICG1AlVDCYxFVYZ6fp7ytw7mRs=",
+      "dev": true
+    },
+    "debug": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+      "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+      "dev": true,
+      "requires": {
+        "ms": "2.1.2"
+      }
+    },
+    "decompress-response": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz",
+      "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=",
+      "dev": true,
+      "requires": {
+        "mimic-response": "^1.0.0"
+      }
+    },
+    "deep-extend": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
+      "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
+      "dev": true
+    },
     "deepmerge": {
       "version": "4.2.2",
       "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz",
       "integrity": "sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==",
       "dev": true
     },
+    "defer-to-connect": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-1.1.3.tgz",
+      "integrity": "sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==",
+      "dev": true
+    },
+    "define-properties": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+      "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "object-keys": "^1.0.12"
+      }
+    },
     "detect-indent": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-6.0.0.tgz",
       "integrity": "sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA==",
       "dev": true
     },
+    "detect-node": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz",
+      "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==",
+      "dev": true,
+      "optional": true
+    },
+    "dir-compare": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/dir-compare/-/dir-compare-2.4.0.tgz",
+      "integrity": "sha512-l9hmu8x/rjVC9Z2zmGzkhOEowZvW7pmYws5CWHutg8u1JgvsKWMx7Q/UODeu4djLZ4FgW5besw5yvMQnBHzuCA==",
+      "dev": true,
+      "requires": {
+        "buffer-equal": "1.0.0",
+        "colors": "1.0.3",
+        "commander": "2.9.0",
+        "minimatch": "3.0.4"
+      },
+      "dependencies": {
+        "colors": {
+          "version": "1.0.3",
+          "resolved": "https://registry.npmjs.org/colors/-/colors-1.0.3.tgz",
+          "integrity": "sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs=",
+          "dev": true
+        },
+        "commander": {
+          "version": "2.9.0",
+          "resolved": "https://registry.npmjs.org/commander/-/commander-2.9.0.tgz",
+          "integrity": "sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q=",
+          "dev": true,
+          "requires": {
+            "graceful-readlink": ">= 1.0.0"
+          }
+        }
+      }
+    },
+    "dmg-builder": {
+      "version": "22.11.7",
+      "resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-22.11.7.tgz",
+      "integrity": "sha512-+I+XfP2DODHB6PwFANgpH/WMzzCA5r5XoMvbFCIYjQjJpXlO0XnqQaamzFl2vh/Wz/Qt0d0lJMgRy8gKR3MGdQ==",
+      "dev": true,
+      "requires": {
+        "app-builder-lib": "22.11.7",
+        "builder-util": "22.11.7",
+        "builder-util-runtime": "8.7.6",
+        "dmg-license": "^1.0.9",
+        "fs-extra": "^10.0.0",
+        "iconv-lite": "^0.6.2",
+        "js-yaml": "^4.1.0"
+      },
+      "dependencies": {
+        "builder-util-runtime": {
+          "version": "8.7.6",
+          "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-8.7.6.tgz",
+          "integrity": "sha512-rj9AIY7CzLSuTOXpToiaQkruYh6UEQ+kYnd5UET22ch8MGClEtIZKXHG14qEiXEr2x4EOKDMxkcTa+9TYaE+ug==",
+          "dev": true,
+          "requires": {
+            "debug": "^4.3.2",
+            "sax": "^1.2.4"
+          }
+        },
+        "debug": {
+          "version": "4.3.2",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.2.tgz",
+          "integrity": "sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==",
+          "dev": true,
+          "requires": {
+            "ms": "2.1.2"
+          }
+        },
+        "fs-extra": {
+          "version": "10.0.0",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.0.0.tgz",
+          "integrity": "sha512-C5owb14u9eJwizKGdchcDUQeFtlSHHthBk8pbX9Vc1PFZrLombudjDnNns88aYslCyF6IY5SUw3Roz6xShcEIQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "iconv-lite": {
+          "version": "0.6.3",
+          "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+          "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+          "dev": true,
+          "requires": {
+            "safer-buffer": ">= 2.1.2 < 3.0.0"
+          }
+        },
+        "jsonfile": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+          "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.6",
+            "universalify": "^2.0.0"
+          }
+        },
+        "universalify": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+          "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+          "dev": true
+        }
+      }
+    },
+    "dmg-license": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/dmg-license/-/dmg-license-1.0.9.tgz",
+      "integrity": "sha512-Rq6qMDaDou2+aPN2SYy0x7LDznoJ/XaG6oDcH5wXUp+WRWQMUYE6eM+F+nex+/LSXOp1uw4HLFoed0YbfU8R/Q==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "@types/plist": "^3.0.1",
+        "@types/verror": "^1.10.3",
+        "ajv": "^6.10.0",
+        "cli-truncate": "^1.1.0",
+        "crc": "^3.8.0",
+        "iconv-corefoundation": "^1.1.6",
+        "plist": "^3.0.1",
+        "smart-buffer": "^4.0.2",
+        "verror": "^1.10.0"
+      }
+    },
+    "dot-prop": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-5.3.0.tgz",
+      "integrity": "sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==",
+      "dev": true,
+      "requires": {
+        "is-obj": "^2.0.0"
+      }
+    },
+    "dotenv": {
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-9.0.2.tgz",
+      "integrity": "sha512-I9OvvrHp4pIARv4+x9iuewrWycX6CcZtoAu1XrzPxc5UygMJXJZYmBsynku8IkrJwgypE5DGNjDPmPRhDCptUg==",
+      "dev": true
+    },
+    "dotenv-expand": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-5.1.0.tgz",
+      "integrity": "sha512-YXQl1DSa4/PQyRfgrv6aoNjhasp/p4qs9FjJ4q4cQk+8m4r6k4ZSiEyytKG8f8W9gi8WsQtIObNmKd+tMzNTmA==",
+      "dev": true
+    },
+    "duplexer3": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz",
+      "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=",
+      "dev": true
+    },
+    "ejs": {
+      "version": "3.1.6",
+      "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.6.tgz",
+      "integrity": "sha512-9lt9Zse4hPucPkoP7FHDF0LQAlGyF9JVpnClFLFH3aSSbxmyoqINRpp/9wePWJTUl4KOQwRL72Iw3InHPDkoGw==",
+      "dev": true,
+      "requires": {
+        "jake": "^10.6.1"
+      }
+    },
+    "electron": {
+      "version": "13.1.2",
+      "resolved": "https://registry.npmjs.org/electron/-/electron-13.1.2.tgz",
+      "integrity": "sha512-aNT9t+LgdQaZ7FgN36pN7MjSEoj+EWc2T9yuOqBApbmR4HavGRadSz7u9N2Erw2ojdIXtei2RVIAvVm8mbDZ0g==",
+      "dev": true,
+      "requires": {
+        "@electron/get": "^1.0.1",
+        "@types/node": "^14.6.2",
+        "extract-zip": "^1.0.3"
+      },
+      "dependencies": {
+        "@types/node": {
+          "version": "14.17.3",
+          "resolved": "https://registry.npmjs.org/@types/node/-/node-14.17.3.tgz",
+          "integrity": "sha512-e6ZowgGJmTuXa3GyaPbTGxX17tnThl2aSSizrFthQ7m9uLGZBXiGhgE55cjRZTF5kjZvYn9EOPOMljdjwbflxw==",
+          "dev": true
+        }
+      }
+    },
+    "electron-builder": {
+      "version": "22.11.7",
+      "resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-22.11.7.tgz",
+      "integrity": "sha512-yQExSLt7Hbz/P8lLkZDdE/OnJJ7NCX+uiQcV+XIH0TeEZcD87ZnSqBBzGUN5akySU4BXXlrVZKeUsXACWrm5Kw==",
+      "dev": true,
+      "requires": {
+        "@types/yargs": "^16.0.2",
+        "app-builder-lib": "22.11.7",
+        "builder-util": "22.11.7",
+        "builder-util-runtime": "8.7.7",
+        "chalk": "^4.1.1",
+        "dmg-builder": "22.11.7",
+        "fs-extra": "^10.0.0",
+        "is-ci": "^3.0.0",
+        "lazy-val": "^1.0.5",
+        "read-config-file": "6.2.0",
+        "update-notifier": "^5.1.0",
+        "yargs": "^17.0.1"
+      },
+      "dependencies": {
+        "fs-extra": {
+          "version": "10.0.0",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.0.0.tgz",
+          "integrity": "sha512-C5owb14u9eJwizKGdchcDUQeFtlSHHthBk8pbX9Vc1PFZrLombudjDnNns88aYslCyF6IY5SUw3Roz6xShcEIQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "is-fullwidth-code-point": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+          "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+          "dev": true
+        },
+        "jsonfile": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+          "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.6",
+            "universalify": "^2.0.0"
+          }
+        },
+        "string-width": {
+          "version": "4.2.2",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz",
+          "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.0"
+          }
+        },
+        "universalify": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+          "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+          "dev": true
+        },
+        "yargs": {
+          "version": "17.0.1",
+          "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.0.1.tgz",
+          "integrity": "sha512-xBBulfCc8Y6gLFcrPvtqKz9hz8SO0l1Ni8GgDekvBX2ro0HRQImDGnikfc33cgzcYUSncapnNcZDjVFIH3f6KQ==",
+          "dev": true,
+          "requires": {
+            "cliui": "^7.0.2",
+            "escalade": "^3.1.1",
+            "get-caller-file": "^2.0.5",
+            "require-directory": "^2.1.1",
+            "string-width": "^4.2.0",
+            "y18n": "^5.0.5",
+            "yargs-parser": "^20.2.2"
+          }
+        }
+      }
+    },
+    "electron-publish": {
+      "version": "22.11.7",
+      "resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-22.11.7.tgz",
+      "integrity": "sha512-A4EhRRNBVz4SPzUlBrPO6BmuyDeI0pyprggPAV9rQ+SDVSnSB/WKPot9JwWMyArkGj3AUUTMNVT6hwZhMvhfqw==",
+      "dev": true,
+      "requires": {
+        "@types/fs-extra": "^9.0.11",
+        "builder-util": "22.11.7",
+        "builder-util-runtime": "8.7.7",
+        "chalk": "^4.1.1",
+        "fs-extra": "^10.0.0",
+        "lazy-val": "^1.0.5",
+        "mime": "^2.5.2"
+      },
+      "dependencies": {
+        "fs-extra": {
+          "version": "10.0.0",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.0.0.tgz",
+          "integrity": "sha512-C5owb14u9eJwizKGdchcDUQeFtlSHHthBk8pbX9Vc1PFZrLombudjDnNns88aYslCyF6IY5SUw3Roz6xShcEIQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "jsonfile": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+          "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.6",
+            "universalify": "^2.0.0"
+          }
+        },
+        "universalify": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+          "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+          "dev": true
+        }
+      }
+    },
+    "electron-squirrel-startup": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/electron-squirrel-startup/-/electron-squirrel-startup-1.0.0.tgz",
+      "integrity": "sha1-GbTlWTP6Dvj1VnhLnGYPdyVGoLg=",
+      "requires": {
+        "debug": "^2.2.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+        }
+      }
+    },
+    "electron-winstaller": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/electron-winstaller/-/electron-winstaller-5.0.0.tgz",
+      "integrity": "sha512-V+jFda7aVAm0htCG8Q95buPUpmXZW9ujh1HdhSlWY6y4QnJnw4TfrmxTlQWV4p2ioF/71JMI/1YF+/qbSICogA==",
+      "dev": true,
+      "requires": {
+        "asar": "^2.0.1",
+        "debug": "^4.1.1",
+        "fs-extra": "^7.0.1",
+        "lodash.template": "^4.2.2",
+        "temp": "^0.9.0"
+      },
+      "dependencies": {
+        "asar": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/asar/-/asar-2.1.0.tgz",
+          "integrity": "sha512-d2Ovma+bfqNpvBzY/KU8oPY67ZworixTpkjSx0PCXnQi67c2cXmssaTxpFDUM0ttopXoGx/KRxNg/GDThYbXQA==",
+          "dev": true,
+          "requires": {
+            "@types/glob": "^7.1.1",
+            "chromium-pickle-js": "^0.2.0",
+            "commander": "^2.20.0",
+            "cuint": "^0.2.2",
+            "glob": "^7.1.3",
+            "minimatch": "^3.0.4",
+            "mkdirp": "^0.5.1",
+            "tmp-promise": "^1.0.5"
+          }
+        },
+        "fs-extra": {
+          "version": "7.0.1",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz",
+          "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.2",
+            "jsonfile": "^4.0.0",
+            "universalify": "^0.1.0"
+          }
+        },
+        "tmp": {
+          "version": "0.1.0",
+          "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.1.0.tgz",
+          "integrity": "sha512-J7Z2K08jbGcdA1kkQpJSqLF6T0tdQqpR2pnSUXsIchbPdTI9v3e85cLW0d6WDhwuAleOV71j2xWs8qMPfK7nKw==",
+          "dev": true,
+          "requires": {
+            "rimraf": "^2.6.3"
+          }
+        },
+        "tmp-promise": {
+          "version": "1.1.0",
+          "resolved": "https://registry.npmjs.org/tmp-promise/-/tmp-promise-1.1.0.tgz",
+          "integrity": "sha512-8+Ah9aB1IRXCnIOxXZ0uFozV1nMU5xiu7hhFVUSxZ3bYu+psD4TzagCzVbexUCgNNGJnsmNDQlS4nG3mTyoNkw==",
+          "dev": true,
+          "requires": {
+            "bluebird": "^3.5.0",
+            "tmp": "0.1.0"
+          }
+        }
+      }
+    },
+    "emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true
+    },
+    "encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=",
+      "dev": true,
+      "optional": true
+    },
+    "end-of-stream": {
+      "version": "1.4.4",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
+      "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
+      "dev": true,
+      "requires": {
+        "once": "^1.4.0"
+      }
+    },
+    "env-paths": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
+      "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
+      "dev": true
+    },
+    "es6-error": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
+      "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",
+      "dev": true,
+      "optional": true
+    },
+    "escalade": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
+      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "dev": true
+    },
+    "escape-goat": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/escape-goat/-/escape-goat-2.1.1.tgz",
+      "integrity": "sha512-8/uIhbG12Csjy2JEW7D9pHbreaVaS/OpN3ycnyvElTdwM5n6GY6W6e2IPemfvGZeUMqZ9A/3GqIZMgKnBhAw/Q==",
+      "dev": true
+    },
     "escape-string-regexp": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
@@ -356,6 +1674,72 @@
       "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
       "dev": true
     },
+    "extract-zip": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-1.7.0.tgz",
+      "integrity": "sha512-xoh5G1W/PB0/27lXgMQyIhP5DSY/LhoCsOyZgb+6iMmRtCwVBo55uKaMoEYrDCKQhWvqEip5ZPKAc6eFNyf/MA==",
+      "dev": true,
+      "requires": {
+        "concat-stream": "^1.6.2",
+        "debug": "^2.6.9",
+        "mkdirp": "^0.5.4",
+        "yauzl": "^2.10.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "2.6.9",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+          "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+          "dev": true,
+          "requires": {
+            "ms": "2.0.0"
+          }
+        },
+        "ms": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+          "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
+          "dev": true
+        }
+      }
+    },
+    "extsprintf": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz",
+      "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=",
+      "dev": true,
+      "optional": true
+    },
+    "fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true
+    },
+    "fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true
+    },
+    "fd-slicer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+      "integrity": "sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=",
+      "dev": true,
+      "requires": {
+        "pend": "~1.2.0"
+      }
+    },
+    "filelist": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.2.tgz",
+      "integrity": "sha512-z7O0IS8Plc39rTCq6i6iHxk43duYOn8uFJiWSewIq0Bww1RNybVHSCjahmcC87ZqAm4OTvFzlzeGu3XAzG1ctQ==",
+      "dev": true,
+      "requires": {
+        "minimatch": "^3.0.4"
+      }
+    },
     "fill-range": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
@@ -365,6 +1749,17 @@
         "to-regex-range": "^5.0.1"
       }
     },
+    "fs-extra": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
+      "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
+      "dev": true,
+      "requires": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^4.0.0",
+        "universalify": "^0.1.0"
+      }
+    },
     "fs.realpath": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
@@ -384,11 +1779,26 @@
       "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
       "dev": true
     },
+    "get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true
+    },
     "get-port": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/get-port/-/get-port-3.2.0.tgz",
       "integrity": "sha1-3Xzn3hh8Bsi/NTeWrHHgmfCYDrw="
     },
+    "get-stream": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
+      "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==",
+      "dev": true,
+      "requires": {
+        "pump": "^3.0.0"
+      }
+    },
     "glob": {
       "version": "7.1.7",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz",
@@ -412,6 +1822,105 @@
         "is-glob": "^4.0.1"
       }
     },
+    "global-agent": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-2.2.0.tgz",
+      "integrity": "sha512-+20KpaW6DDLqhG7JDiJpD1JvNvb8ts+TNl7BPOYcURqCrXqnN1Vf+XVOrkKJAFPqfX+oEhsdzOj1hLWkBTdNJg==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "boolean": "^3.0.1",
+        "core-js": "^3.6.5",
+        "es6-error": "^4.1.1",
+        "matcher": "^3.0.0",
+        "roarr": "^2.15.3",
+        "semver": "^7.3.2",
+        "serialize-error": "^7.0.1"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "7.3.5",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz",
+          "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "lru-cache": "^6.0.0"
+          }
+        }
+      }
+    },
+    "global-dirs": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-3.0.0.tgz",
+      "integrity": "sha512-v8ho2DS5RiCjftj1nD9NmnfaOzTdud7RRnVd9kFNOjqZbISlx5DQ+OrTkywgd0dIt7oFCvKetZSHoHcP3sDdiA==",
+      "dev": true,
+      "requires": {
+        "ini": "2.0.0"
+      },
+      "dependencies": {
+        "ini": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz",
+          "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==",
+          "dev": true
+        }
+      }
+    },
+    "global-tunnel-ng": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/global-tunnel-ng/-/global-tunnel-ng-2.7.1.tgz",
+      "integrity": "sha512-4s+DyciWBV0eK148wqXxcmVAbFVPqtc3sEtUE/GTQfuU80rySLcMhUmHKSHI7/LDj8q0gDYI1lIhRRB7ieRAqg==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "encodeurl": "^1.0.2",
+        "lodash": "^4.17.10",
+        "npm-conf": "^1.1.3",
+        "tunnel": "^0.0.6"
+      }
+    },
+    "globalthis": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.2.tgz",
+      "integrity": "sha512-ZQnSFO1la8P7auIOQECnm0sSuoMeaSq0EEdXMBFF2QJO4uNcwbyhSgG3MruWNbFTqCLmxVwGOl7LZ9kASvHdeQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "define-properties": "^1.1.3"
+      }
+    },
+    "got": {
+      "version": "9.6.0",
+      "resolved": "https://registry.npmjs.org/got/-/got-9.6.0.tgz",
+      "integrity": "sha512-R7eWptXuGYxwijs0eV+v3o6+XH1IqVK8dJOEecQfTmkncw9AV4dcw/Dhxi8MdlqPthxxpZyizMzyg8RTmEsG+Q==",
+      "dev": true,
+      "requires": {
+        "@sindresorhus/is": "^0.14.0",
+        "@szmarczak/http-timer": "^1.1.2",
+        "cacheable-request": "^6.0.0",
+        "decompress-response": "^3.3.0",
+        "duplexer3": "^0.1.4",
+        "get-stream": "^4.1.0",
+        "lowercase-keys": "^1.0.1",
+        "mimic-response": "^1.0.1",
+        "p-cancelable": "^1.0.0",
+        "to-readable-stream": "^1.0.0",
+        "url-parse-lax": "^3.0.0"
+      }
+    },
+    "graceful-fs": {
+      "version": "4.2.6",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.6.tgz",
+      "integrity": "sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==",
+      "dev": true
+    },
+    "graceful-readlink": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz",
+      "integrity": "sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=",
+      "dev": true
+    },
     "has": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
@@ -427,6 +1936,36 @@
       "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
       "dev": true
     },
+    "has-yarn": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/has-yarn/-/has-yarn-2.1.0.tgz",
+      "integrity": "sha512-UqBRqi4ju7T+TqGNdqAO0PaSVGsDGJUBQvk9eUWNGRY1CFGDzYhLWoM7JQEemnlvVcv/YEmc2wNW8BC24EnUsw==",
+      "dev": true
+    },
+    "http-cache-semantics": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz",
+      "integrity": "sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==",
+      "dev": true
+    },
+    "iconv-corefoundation": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/iconv-corefoundation/-/iconv-corefoundation-1.1.6.tgz",
+      "integrity": "sha512-1NBe55C75bKGZaY9UHxvXG3G0gEp0ziht7quhuFrW3SPgZDw9HI6qvYXRSV5M/Eupyu8ljuJ6Cba+ec15PZ4Xw==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "cli-truncate": "^1.1.0",
+        "node-addon-api": "^1.6.3"
+      }
+    },
+    "ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "dev": true,
+      "optional": true
+    },
     "import-fresh": {
       "version": "3.3.0",
       "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",
@@ -437,6 +1976,18 @@
         "resolve-from": "^4.0.0"
       }
     },
+    "import-lazy": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/import-lazy/-/import-lazy-2.1.0.tgz",
+      "integrity": "sha1-BWmOPUXIjo1+nZLLBYTnfwlvPkM=",
+      "dev": true
+    },
+    "imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=",
+      "dev": true
+    },
     "inflight": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
@@ -453,6 +2004,12 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "dev": true
     },
+    "ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
+      "dev": true
+    },
     "is-binary-path": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
@@ -462,6 +2019,15 @@
         "binary-extensions": "^2.0.0"
       }
     },
+    "is-ci": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-3.0.0.tgz",
+      "integrity": "sha512-kDXyttuLeslKAHYL/K28F2YkM3x5jvFPEw3yXbRptXydjD9rpLEz+C5K5iutY9ZiUu6AP41JdvRQwF4Iqs4ZCQ==",
+      "dev": true,
+      "requires": {
+        "ci-info": "^3.1.1"
+      }
+    },
     "is-core-module": {
       "version": "2.4.0",
       "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.4.0.tgz",
@@ -486,18 +2052,46 @@
         "is-extglob": "^2.1.1"
       }
     },
+    "is-installed-globally": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.4.0.tgz",
+      "integrity": "sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==",
+      "dev": true,
+      "requires": {
+        "global-dirs": "^3.0.0",
+        "is-path-inside": "^3.0.2"
+      }
+    },
     "is-module": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
       "integrity": "sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=",
       "dev": true
     },
+    "is-npm": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-5.0.0.tgz",
+      "integrity": "sha512-WW/rQLOazUq+ST/bCAVBp/2oMERWLsR7OrKyt052dNDk4DHcDE0/7QSXITlmi+VBcV13DfIbysG3tZJm5RfdBA==",
+      "dev": true
+    },
     "is-number": {
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
       "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
       "dev": true
     },
+    "is-obj": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
+      "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==",
+      "dev": true
+    },
+    "is-path-inside": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
+      "dev": true
+    },
     "is-reference": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz",
@@ -507,6 +2101,94 @@
         "@types/estree": "*"
       }
     },
+    "is-typedarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz",
+      "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=",
+      "dev": true
+    },
+    "is-yarn-global": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/is-yarn-global/-/is-yarn-global-0.3.0.tgz",
+      "integrity": "sha512-VjSeb/lHmkoyd8ryPVIKvOCn4D1koMqY+vqyjjUfc3xyKtP4dYOxM44sZrnqQSzSds3xyOrUTLTC9LVCVgLngw==",
+      "dev": true
+    },
+    "isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=",
+      "dev": true
+    },
+    "isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
+      "dev": true
+    },
+    "jake": {
+      "version": "10.8.2",
+      "resolved": "https://registry.npmjs.org/jake/-/jake-10.8.2.tgz",
+      "integrity": "sha512-eLpKyrfG3mzvGE2Du8VoPbeSkRry093+tyNjdYaBbJS9v17knImYGNXQCUV0gLxQtF82m3E8iRb/wdSQZLoq7A==",
+      "dev": true,
+      "requires": {
+        "async": "0.9.x",
+        "chalk": "^2.4.2",
+        "filelist": "^1.0.1",
+        "minimatch": "^3.0.4"
+      },
+      "dependencies": {
+        "ansi-styles": {
+          "version": "3.2.1",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+          "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+          "dev": true,
+          "requires": {
+            "color-convert": "^1.9.0"
+          }
+        },
+        "chalk": {
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+          "dev": true,
+          "requires": {
+            "ansi-styles": "^3.2.1",
+            "escape-string-regexp": "^1.0.5",
+            "supports-color": "^5.3.0"
+          }
+        },
+        "color-convert": {
+          "version": "1.9.3",
+          "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+          "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+          "dev": true,
+          "requires": {
+            "color-name": "1.1.3"
+          }
+        },
+        "color-name": {
+          "version": "1.1.3",
+          "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+          "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+          "dev": true
+        },
+        "has-flag": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+          "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+          "dev": true
+        },
+        "supports-color": {
+          "version": "5.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+          "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        }
+      }
+    },
     "jest-worker": {
       "version": "26.6.2",
       "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz",
@@ -524,11 +2206,81 @@
       "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
       "dev": true
     },
+    "js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dev": true,
+      "requires": {
+        "argparse": "^2.0.1"
+      }
+    },
+    "json-buffer": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.0.tgz",
+      "integrity": "sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=",
+      "dev": true
+    },
+    "json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true
+    },
+    "json-stringify-safe": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
+      "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=",
+      "dev": true,
+      "optional": true
+    },
+    "json5": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz",
+      "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==",
+      "dev": true,
+      "requires": {
+        "minimist": "^1.2.5"
+      }
+    },
+    "jsonfile": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
+      "integrity": "sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=",
+      "dev": true,
+      "requires": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "keyv": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-3.1.0.tgz",
+      "integrity": "sha512-9ykJ/46SN/9KPM/sichzQ7OvXyGDYKGTaDlKMGCAlg2UK8KRy4jb0d8sFc+0Tt0YYnThq8X2RZgCg74RPxgcVA==",
+      "dev": true,
+      "requires": {
+        "json-buffer": "3.0.0"
+      }
+    },
     "kleur": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
       "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="
     },
+    "latest-version": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/latest-version/-/latest-version-5.1.0.tgz",
+      "integrity": "sha512-weT+r0kTkRQdCdYCNtkMwWXQTMEswKrFBkm4ckQOMVhhqhIMI1UT2hMj+1iigIhgSZm5gTmrRXBNoGUgaTY1xA==",
+      "dev": true,
+      "requires": {
+        "package-json": "^6.3.0"
+      }
+    },
+    "lazy-val": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz",
+      "integrity": "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==",
+      "dev": true
+    },
     "livereload": {
       "version": "0.9.3",
       "resolved": "https://registry.npmjs.org/livereload/-/livereload-0.9.3.tgz",
@@ -552,11 +2304,57 @@
       "resolved": "https://registry.npmjs.org/local-access/-/local-access-1.1.0.tgz",
       "integrity": "sha512-XfegD5pyTAfb+GY6chk283Ox5z8WexG56OvM06RWLpAc/UHozO8X6xAxEkIitZOtsSMM1Yr3DkHgW5W+onLhCw=="
     },
+    "lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "dev": true
+    },
+    "lodash._reinterpolate": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz",
+      "integrity": "sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=",
+      "dev": true
+    },
     "lodash.clonedeep": {
       "version": "4.5.0",
       "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz",
       "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8="
     },
+    "lodash.template": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.template/-/lodash.template-4.5.0.tgz",
+      "integrity": "sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==",
+      "dev": true,
+      "requires": {
+        "lodash._reinterpolate": "^3.0.0",
+        "lodash.templatesettings": "^4.0.0"
+      }
+    },
+    "lodash.templatesettings": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz",
+      "integrity": "sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==",
+      "dev": true,
+      "requires": {
+        "lodash._reinterpolate": "^3.0.0"
+      }
+    },
+    "lowercase-keys": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz",
+      "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==",
+      "dev": true
+    },
+    "lru-cache": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+      "dev": true,
+      "requires": {
+        "yallist": "^4.0.0"
+      }
+    },
     "magic-string": {
       "version": "0.25.7",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.25.7.tgz",
@@ -566,6 +2364,34 @@
         "sourcemap-codec": "^1.4.4"
       }
     },
+    "make-dir": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+      "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+      "dev": true,
+      "requires": {
+        "semver": "^6.0.0"
+      }
+    },
+    "matcher": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz",
+      "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "escape-string-regexp": "^4.0.0"
+      },
+      "dependencies": {
+        "escape-string-regexp": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+          "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+          "dev": true,
+          "optional": true
+        }
+      }
+    },
     "merge-stream": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
@@ -577,6 +2403,12 @@
       "resolved": "https://registry.npmjs.org/mime/-/mime-2.5.2.tgz",
       "integrity": "sha512-tqkh47FzKeCPD2PUiPB6pkbMzsCasjxAfC62/Wap5qrUWcb+sFasXUC5I3gYM5iBM8v/Qpn4UK0x+j0iHyFPDg=="
     },
+    "mimic-response": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz",
+      "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==",
+      "dev": true
+    },
     "min-indent": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
@@ -598,17 +2430,63 @@
       "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==",
       "dev": true
     },
+    "mkdirp": {
+      "version": "0.5.5",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz",
+      "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==",
+      "dev": true,
+      "requires": {
+        "minimist": "^1.2.5"
+      }
+    },
     "mri": {
       "version": "1.1.6",
       "resolved": "https://registry.npmjs.org/mri/-/mri-1.1.6.tgz",
       "integrity": "sha512-oi1b3MfbyGa7FJMP9GmLTttni5JoICpYBRlq+x5V16fZbLsnL9N3wFqqIm/nIG43FjUFkFh9Epzp/kzUGUnJxQ=="
     },
+    "ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "dev": true
+    },
+    "node-addon-api": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.2.tgz",
+      "integrity": "sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg==",
+      "dev": true,
+      "optional": true
+    },
     "normalize-path": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
       "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
       "dev": true
     },
+    "normalize-url": {
+      "version": "4.5.1",
+      "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-4.5.1.tgz",
+      "integrity": "sha512-9UZCFRHQdNrfTpGg8+1INIg93B6zE0aXMVFkw1WFwvO4SlZywU6aLg5Of0Ap/PgcbSw4LNxvMWXMeugwMCX0AA==",
+      "dev": true
+    },
+    "npm-conf": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/npm-conf/-/npm-conf-1.1.3.tgz",
+      "integrity": "sha512-Yic4bZHJOt9RCFbRP3GgpqhScOY4HH3V2P8yBj6CeYq118Qr+BLXqT2JvpJ00mryLESpgOxf5XlFv4ZjXxLScw==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "config-chain": "^1.1.11",
+        "pify": "^3.0.0"
+      }
+    },
+    "object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+      "dev": true,
+      "optional": true
+    },
     "once": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
@@ -624,6 +2502,24 @@
       "integrity": "sha512-k41FwbcLnlgnFh69f4qdUfvDQ+5vaSDnVPFI/y5XuhKRq97EnVVneO9F1ESVCdiVu4fCS2L8usX3mU331hB7pg==",
       "dev": true
     },
+    "p-cancelable": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-1.1.0.tgz",
+      "integrity": "sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==",
+      "dev": true
+    },
+    "package-json": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/package-json/-/package-json-6.5.0.tgz",
+      "integrity": "sha512-k3bdm2n25tkyxcjSKzB5x8kfVxlMdgsbPr0GkZcwHsLpba6cBjqCt1KlcChKEvxHIcTB1FVMuwoijZ26xex5MQ==",
+      "dev": true,
+      "requires": {
+        "got": "^9.6.0",
+        "registry-auth-token": "^4.0.0",
+        "registry-url": "^5.0.0",
+        "semver": "^6.2.0"
+      }
+    },
     "parent-module": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
@@ -639,18 +2535,99 @@
       "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
       "dev": true
     },
+    "path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true
+    },
     "path-parse": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
       "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
       "dev": true
     },
+    "pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha1-elfrVQpng/kRUzH89GY9XI4AelA=",
+      "dev": true
+    },
     "picomatch": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.0.tgz",
       "integrity": "sha512-lY1Q/PiJGC2zOv/z391WOTD+Z02bCgsFfvxoXXf6h7kv9o+WmsmzYqrAwY63sNgOxE4xEdq0WyUnXfKeBrSvYw==",
       "dev": true
     },
+    "pify": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
+      "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=",
+      "dev": true,
+      "optional": true
+    },
+    "plist": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/plist/-/plist-3.0.2.tgz",
+      "integrity": "sha512-MSrkwZBdQ6YapHy87/8hDU8MnIcyxBKjeF+McXnr5A9MtffPewTs7G3hlpodT5TacyfIyFTaJEhh3GGcmasTgQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "base64-js": "^1.5.1",
+        "xmlbuilder": "^9.0.7",
+        "xmldom": "^0.5.0"
+      }
+    },
+    "prepend-http": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-2.0.0.tgz",
+      "integrity": "sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=",
+      "dev": true
+    },
+    "process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "dev": true
+    },
+    "progress": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+      "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+      "dev": true
+    },
+    "proto-list": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz",
+      "integrity": "sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=",
+      "dev": true,
+      "optional": true
+    },
+    "pump": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
+      "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==",
+      "dev": true,
+      "requires": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "punycode": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
+      "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
+      "dev": true
+    },
+    "pupa": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/pupa/-/pupa-2.1.1.tgz",
+      "integrity": "sha512-l1jNAspIBSFqbT+y+5FosojNpVpF94nlI+wDUpqP9enwOTfHx9f0gh5nB96vl+6yTpsJsypeNrwfzPrKuHB41A==",
+      "dev": true,
+      "requires": {
+        "escape-goat": "^2.0.0"
+      }
+    },
     "randombytes": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
@@ -660,6 +2637,54 @@
         "safe-buffer": "^5.1.0"
       }
     },
+    "rc": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
+      "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
+      "dev": true,
+      "requires": {
+        "deep-extend": "^0.6.0",
+        "ini": "~1.3.0",
+        "minimist": "^1.2.0",
+        "strip-json-comments": "~2.0.1"
+      }
+    },
+    "read-config-file": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/read-config-file/-/read-config-file-6.2.0.tgz",
+      "integrity": "sha512-gx7Pgr5I56JtYz+WuqEbQHj/xWo+5Vwua2jhb1VwM4Wid5PqYmZ4i00ZB0YEGIfkVBsCv9UrjgyqCiQfS/Oosg==",
+      "dev": true,
+      "requires": {
+        "dotenv": "^9.0.2",
+        "dotenv-expand": "^5.1.0",
+        "js-yaml": "^4.1.0",
+        "json5": "^2.2.0",
+        "lazy-val": "^1.0.4"
+      }
+    },
+    "readable-stream": {
+      "version": "2.3.7",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
+      "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
+      "dev": true,
+      "requires": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      },
+      "dependencies": {
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "dev": true
+        }
+      }
+    },
     "readdirp": {
       "version": "3.5.0",
       "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.5.0.tgz",
@@ -669,6 +2694,30 @@
         "picomatch": "^2.2.1"
       }
     },
+    "registry-auth-token": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-4.2.1.tgz",
+      "integrity": "sha512-6gkSb4U6aWJB4SF2ZvLb76yCBjcvufXBqvvEx1HbmKPkutswjW1xNVRY0+daljIYRbogN7O0etYSlbiaEQyMyw==",
+      "dev": true,
+      "requires": {
+        "rc": "^1.2.8"
+      }
+    },
+    "registry-url": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/registry-url/-/registry-url-5.1.0.tgz",
+      "integrity": "sha512-8acYXXTI0AkQv6RAOjE3vOaIXZkT9wo4LOFbBKYQEEnnMNBpKqdUrI6S4NT0KPIo/WVvJ5tE/X5LF/TQUf0ekw==",
+      "dev": true,
+      "requires": {
+        "rc": "^1.2.8"
+      }
+    },
+    "require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
+      "dev": true
+    },
     "require-relative": {
       "version": "0.8.7",
       "resolved": "https://registry.npmjs.org/require-relative/-/require-relative-0.8.7.tgz",
@@ -691,6 +2740,39 @@
       "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
       "dev": true
     },
+    "responselike": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/responselike/-/responselike-1.0.2.tgz",
+      "integrity": "sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec=",
+      "dev": true,
+      "requires": {
+        "lowercase-keys": "^1.0.0"
+      }
+    },
+    "rimraf": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz",
+      "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==",
+      "dev": true,
+      "requires": {
+        "glob": "^7.1.3"
+      }
+    },
+    "roarr": {
+      "version": "2.15.4",
+      "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz",
+      "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "boolean": "^3.0.1",
+        "detect-node": "^2.0.4",
+        "globalthis": "^1.0.1",
+        "json-stringify-safe": "^5.0.1",
+        "semver-compare": "^1.0.0",
+        "sprintf-js": "^1.1.2"
+      }
+    },
     "rollup": {
       "version": "2.49.0",
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.49.0.tgz",
@@ -783,11 +2865,64 @@
       "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
       "dev": true
     },
+    "safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true
+    },
+    "sanitize-filename": {
+      "version": "1.6.3",
+      "resolved": "https://registry.npmjs.org/sanitize-filename/-/sanitize-filename-1.6.3.tgz",
+      "integrity": "sha512-y/52Mcy7aw3gRm7IrcGDFx/bCk4AhRh2eI9luHOQM86nZsqwiRkkq2GekHXBBD+SmPidc8i2PqtYZl+pWJ8Oeg==",
+      "dev": true,
+      "requires": {
+        "truncate-utf8-bytes": "^1.0.0"
+      }
+    },
+    "sax": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
+      "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==",
+      "dev": true
+    },
     "semiver": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/semiver/-/semiver-1.1.0.tgz",
       "integrity": "sha512-QNI2ChmuioGC1/xjyYwyZYADILWyW6AmS1UH6gDj/SFUUUS4MBAWs/7mxnkRPc/F4iHezDP+O8t0dO8WHiEOdg=="
     },
+    "semver": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+      "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+      "dev": true
+    },
+    "semver-compare": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz",
+      "integrity": "sha1-De4hahyUGrN+nvsXiPavxf9VN/w=",
+      "dev": true,
+      "optional": true
+    },
+    "semver-diff": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-3.1.1.tgz",
+      "integrity": "sha512-GX0Ix/CJcHyB8c4ykpHGIAvLyOwOobtM/8d+TQkAd81/bEjgPHrfba41Vpesr7jX/t8Uh+R3EX9eAS5be+jQYg==",
+      "dev": true,
+      "requires": {
+        "semver": "^6.3.0"
+      }
+    },
+    "serialize-error": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz",
+      "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "type-fest": "^0.13.1"
+      }
+    },
     "serialize-javascript": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-4.0.0.tgz",
@@ -797,6 +2932,27 @@
         "randombytes": "^2.1.0"
       }
     },
+    "shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "requires": {
+        "shebang-regex": "^3.0.0"
+      }
+    },
+    "shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true
+    },
+    "signal-exit": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz",
+      "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==",
+      "dev": true
+    },
     "sirv": {
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/sirv/-/sirv-1.0.11.tgz",
@@ -822,6 +2978,32 @@
         "tinydate": "^1.0.0"
       }
     },
+    "slice-ansi": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz",
+      "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "is-fullwidth-code-point": "^2.0.0"
+      },
+      "dependencies": {
+        "is-fullwidth-code-point": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+          "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+          "dev": true,
+          "optional": true
+        }
+      }
+    },
+    "smart-buffer": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.1.0.tgz",
+      "integrity": "sha512-iVICrxOzCynf/SNaBQCw34eM9jROU/s5rzIhpOvzhzuYHfJR/DhZfDkXiZSgKXfgv26HT3Yni3AV/DGw0cGnnw==",
+      "dev": true,
+      "optional": true
+    },
     "source-map": {
       "version": "0.7.3",
       "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
@@ -850,6 +3032,45 @@
       "integrity": "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==",
       "dev": true
     },
+    "sprintf-js": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.2.tgz",
+      "integrity": "sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug==",
+      "dev": true,
+      "optional": true
+    },
+    "stat-mode": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz",
+      "integrity": "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==",
+      "dev": true
+    },
+    "string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "dev": true,
+      "requires": {
+        "safe-buffer": "~5.1.0"
+      },
+      "dependencies": {
+        "safe-buffer": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "dev": true
+        }
+      }
+    },
+    "strip-ansi": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz",
+      "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==",
+      "dev": true,
+      "requires": {
+        "ansi-regex": "^5.0.0"
+      }
+    },
     "strip-indent": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
@@ -859,6 +3080,21 @@
         "min-indent": "^1.0.0"
       }
     },
+    "strip-json-comments": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+      "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=",
+      "dev": true
+    },
+    "sumchecker": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz",
+      "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==",
+      "dev": true,
+      "requires": {
+        "debug": "^4.1.0"
+      }
+    },
     "supports-color": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
@@ -902,6 +3138,66 @@
         "strip-indent": "^3.0.0"
       }
     },
+    "temp": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/temp/-/temp-0.9.4.tgz",
+      "integrity": "sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA==",
+      "dev": true,
+      "requires": {
+        "mkdirp": "^0.5.1",
+        "rimraf": "~2.6.2"
+      },
+      "dependencies": {
+        "rimraf": {
+          "version": "2.6.3",
+          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
+          "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+          "dev": true,
+          "requires": {
+            "glob": "^7.1.3"
+          }
+        }
+      }
+    },
+    "temp-file": {
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/temp-file/-/temp-file-3.4.0.tgz",
+      "integrity": "sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg==",
+      "dev": true,
+      "requires": {
+        "async-exit-hook": "^2.0.1",
+        "fs-extra": "^10.0.0"
+      },
+      "dependencies": {
+        "fs-extra": {
+          "version": "10.0.0",
+          "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.0.0.tgz",
+          "integrity": "sha512-C5owb14u9eJwizKGdchcDUQeFtlSHHthBk8pbX9Vc1PFZrLombudjDnNns88aYslCyF6IY5SUw3Roz6xShcEIQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.2.0",
+            "jsonfile": "^6.0.1",
+            "universalify": "^2.0.0"
+          }
+        },
+        "jsonfile": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+          "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+          "dev": true,
+          "requires": {
+            "graceful-fs": "^4.1.6",
+            "universalify": "^2.0.0"
+          }
+        },
+        "universalify": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+          "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+          "dev": true
+        }
+      }
+    },
     "terser": {
       "version": "5.7.0",
       "resolved": "https://registry.npmjs.org/terser/-/terser-5.7.0.tgz",
@@ -923,6 +3219,41 @@
       "resolved": "https://registry.npmjs.org/tinydate/-/tinydate-1.3.0.tgz",
       "integrity": "sha512-7cR8rLy2QhYHpsBDBVYnnWXm8uRTr38RoZakFSW7Bs7PzfMPNZthuMLkwqZv7MTu8lhQ91cOFYS5a7iFj2oR3w=="
     },
+    "tmp-promise": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/tmp-promise/-/tmp-promise-3.0.2.tgz",
+      "integrity": "sha512-OyCLAKU1HzBjL6Ev3gxUeraJNlbNingmi8IrHHEsYH8LTmEuhvYfqvhn2F/je+mjf4N58UmZ96OMEy1JanSCpA==",
+      "dev": true,
+      "requires": {
+        "tmp": "^0.2.0"
+      },
+      "dependencies": {
+        "rimraf": {
+          "version": "3.0.2",
+          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+          "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+          "dev": true,
+          "requires": {
+            "glob": "^7.1.3"
+          }
+        },
+        "tmp": {
+          "version": "0.2.1",
+          "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.1.tgz",
+          "integrity": "sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==",
+          "dev": true,
+          "requires": {
+            "rimraf": "^3.0.0"
+          }
+        }
+      }
+    },
+    "to-readable-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/to-readable-stream/-/to-readable-stream-1.0.0.tgz",
+      "integrity": "sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q==",
+      "dev": true
+    },
     "to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -937,6 +3268,15 @@
       "resolved": "https://registry.npmjs.org/totalist/-/totalist-1.1.0.tgz",
       "integrity": "sha512-gduQwd1rOdDMGxFG1gEvhV88Oirdo2p+KjoYFU7k2g+i7n6AFFbDQ5kMPUsW0pNbfQsB/cwXvT1i4Bue0s9g5g=="
     },
+    "truncate-utf8-bytes": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz",
+      "integrity": "sha1-QFkjkJWS1W94pYGENLC3hInKXys=",
+      "dev": true,
+      "requires": {
+        "utf8-byte-length": "^1.0.1"
+      }
+    },
     "ts-mixer": {
       "version": "5.4.1",
       "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-5.4.1.tgz",
@@ -948,11 +3288,145 @@
       "integrity": "sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==",
       "dev": true
     },
+    "tunnel": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
+      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==",
+      "dev": true,
+      "optional": true
+    },
+    "type-fest": {
+      "version": "0.13.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz",
+      "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==",
+      "dev": true,
+      "optional": true
+    },
+    "typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=",
+      "dev": true
+    },
+    "typedarray-to-buffer": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
+      "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
+      "dev": true,
+      "requires": {
+        "is-typedarray": "^1.0.0"
+      }
+    },
     "typescript": {
       "version": "4.4.0-dev.20210525",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.4.0-dev.20210525.tgz",
       "integrity": "sha512-hpPEilDaUKKUgh7UmsjDzf3+8dSVICYRHxrXLFOhhKe5gHktNYVFGYdRhUApIPbWhAbwJxIssM3X89QW/+y/+A=="
     },
+    "unique-string": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz",
+      "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==",
+      "dev": true,
+      "requires": {
+        "crypto-random-string": "^2.0.0"
+      }
+    },
+    "universalify": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
+      "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
+      "dev": true
+    },
+    "update-notifier": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-5.1.0.tgz",
+      "integrity": "sha512-ItnICHbeMh9GqUy31hFPrD1kcuZ3rpxDZbf4KUDavXwS0bW5m7SLbDQpGX3UYr072cbrF5hFUs3r5tUsPwjfHw==",
+      "dev": true,
+      "requires": {
+        "boxen": "^5.0.0",
+        "chalk": "^4.1.0",
+        "configstore": "^5.0.1",
+        "has-yarn": "^2.1.0",
+        "import-lazy": "^2.1.0",
+        "is-ci": "^2.0.0",
+        "is-installed-globally": "^0.4.0",
+        "is-npm": "^5.0.0",
+        "is-yarn-global": "^0.3.0",
+        "latest-version": "^5.1.0",
+        "pupa": "^2.1.1",
+        "semver": "^7.3.4",
+        "semver-diff": "^3.1.1",
+        "xdg-basedir": "^4.0.0"
+      },
+      "dependencies": {
+        "ci-info": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz",
+          "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==",
+          "dev": true
+        },
+        "is-ci": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-2.0.0.tgz",
+          "integrity": "sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==",
+          "dev": true,
+          "requires": {
+            "ci-info": "^2.0.0"
+          }
+        },
+        "semver": {
+          "version": "7.3.5",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz",
+          "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==",
+          "dev": true,
+          "requires": {
+            "lru-cache": "^6.0.0"
+          }
+        }
+      }
+    },
+    "uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "requires": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "url-parse-lax": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-3.0.0.tgz",
+      "integrity": "sha1-FrXK/Afb42dsGxmZF3gj1lA6yww=",
+      "dev": true,
+      "requires": {
+        "prepend-http": "^2.0.0"
+      }
+    },
+    "utf8-byte-length": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.4.tgz",
+      "integrity": "sha1-9F8VDExm7uloGGUFq5P8u4rWv2E=",
+      "dev": true
+    },
+    "util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
+      "dev": true
+    },
+    "verror": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz",
+      "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "assert-plus": "^1.0.0",
+        "core-util-is": "1.0.2",
+        "extsprintf": "^1.2.0"
+      }
+    },
     "visitor-as": {
       "version": "0.5.0",
       "resolved": "https://registry.npmjs.org/visitor-as/-/visitor-as-0.5.0.tgz",
@@ -962,17 +3436,144 @@
         "ts-mixer": "^5.1.0"
       }
     },
+    "which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "requires": {
+        "isexe": "^2.0.0"
+      }
+    },
+    "widest-line": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-3.1.0.tgz",
+      "integrity": "sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==",
+      "dev": true,
+      "requires": {
+        "string-width": "^4.0.0"
+      },
+      "dependencies": {
+        "is-fullwidth-code-point": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+          "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "4.2.2",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz",
+          "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.0"
+          }
+        }
+      }
+    },
+    "wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "dependencies": {
+        "is-fullwidth-code-point": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+          "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "4.2.2",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz",
+          "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^8.0.0",
+            "is-fullwidth-code-point": "^3.0.0",
+            "strip-ansi": "^6.0.0"
+          }
+        }
+      }
+    },
     "wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
       "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
       "dev": true
     },
+    "write-file-atomic": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz",
+      "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==",
+      "dev": true,
+      "requires": {
+        "imurmurhash": "^0.1.4",
+        "is-typedarray": "^1.0.0",
+        "signal-exit": "^3.0.2",
+        "typedarray-to-buffer": "^3.1.5"
+      }
+    },
     "ws": {
       "version": "7.4.5",
       "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.5.tgz",
       "integrity": "sha512-xzyu3hFvomRfXKH8vOFMU3OguG6oOvhXMo3xsGy3xWExqaM2dxBbVxuD99O7m3ZUFMvvscsZDqxfgMaRr/Nr1g==",
       "dev": true
+    },
+    "xdg-basedir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-4.0.0.tgz",
+      "integrity": "sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q==",
+      "dev": true
+    },
+    "xmlbuilder": {
+      "version": "9.0.7",
+      "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-9.0.7.tgz",
+      "integrity": "sha1-Ey7mPS7FVlxVfiD0wi35rKaGsQ0=",
+      "dev": true,
+      "optional": true
+    },
+    "xmldom": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/xmldom/-/xmldom-0.5.0.tgz",
+      "integrity": "sha512-Foaj5FXVzgn7xFzsKeNIde9g6aFBxTPi37iwsno8QvApmtg7KYrr+OPyRHcJF7dud2a5nGRBXK3n0dL62Gf7PA==",
+      "dev": true,
+      "optional": true
+    },
+    "y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "dev": true
+    },
+    "yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "dev": true
+    },
+    "yargs-parser": {
+      "version": "20.2.7",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.7.tgz",
+      "integrity": "sha512-FiNkvbeHzB/syOjIUxFDCnhSfzAL8R5vs40MgLFBorXACCOAEaWu0gRZl14vG8MR9AOJIZbmkjhusqBYZ3HTHw==",
+      "dev": true
+    },
+    "yauzl": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+      "integrity": "sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=",
+      "dev": true,
+      "requires": {
+        "buffer-crc32": "~0.2.3",
+        "fd-slicer": "~1.1.0"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index b28b47e..d59a535 100644
--- a/package.json
+++ b/package.json
@@ -2,11 +2,14 @@
   "name": "soma",
   "version": "1.0.0",
   "description": "Custom Somaesque cube solver webapp",
+  "main": "src/desktop/main.js",
   "scripts": {
     "build": "rollup -c",
     "dev": "rollup -c -w",
     "start": "sirv public --no-clear",
-    "validate": "svelte-check"
+    "validate": "svelte-check",
+    "pack": "electron-builder --dir",
+    "dist": "electron-builder"
   },
   "author": "Daniel Ledda",
   "license": "ISC",
@@ -16,6 +19,9 @@
     "@rollup/plugin-typescript": "^8.0.0",
     "@tsconfig/svelte": "^1.0.0",
     "@types/three": "^0.128.0",
+    "electron": "^13.1.2",
+    "electron-builder": "^22.11.7",
+    "electron-winstaller": "^5.0.0",
     "rollup": "^2.3.4",
     "rollup-plugin-css-only": "^3.1.0",
     "rollup-plugin-livereload": "^2.0.0",
@@ -28,9 +34,25 @@
   },
   "dependencies": {
     "as-bind": "^0.7.1",
+    "electron-squirrel-startup": "^1.0.0",
     "sirv-cli": "^1.0.0",
     "source-map-support": "^0.5.19",
     "three": "^0.128.0",
     "typescript": "^4.4.0-dev.20210525"
+  },
+  "build": {
+    "appId": "de.djledda.somaesque",
+    "copyright": "Copyright © 2021 Daniel Ledda",
+    "win": {
+      "target": ["portable"]
+    },
+    "files": [
+      "**/*",
+      "./public/**",
+      "./src/desktop${/*}"
+    ],
+    "directories": {
+      "output": "desktop-dist"
+    }
   }
 }
diff --git a/public/index.html b/public/index.html
index d982c8d..cb4aca3 100644
--- a/public/index.html
+++ b/public/index.html
@@ -4,7 +4,7 @@
 	<meta charset='utf-8'>
 	<meta name='viewport' content='width=device-width,initial-scale=1'>
 
-	<title>Svelte app</title>
+	<title>Somaesque</title>
 
 	<link rel='icon' type='image/png' href='./favicon.png'>
 	<link rel='stylesheet' href='./global.css'>
diff --git a/public/resources/3x3x4.png b/public/resources/3x3x4.png
new file mode 100644
index 0000000000000000000000000000000000000000..c113d5ff6e34b933cd187e35ec740e0e877d8f2f
GIT binary patch
literal 44916
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
T)TJ-bbyqHFTzsc&`tW}Ne;lmK

literal 0
HcmV?d00001

diff --git a/public/resources/ColorWheel.png b/public/resources/ColorWheel.png
new file mode 100644
index 0000000000000000000000000000000000000000..65767af8170056a62db091e8c4cbd9794bbe4d9e
GIT binary patch
literal 75404
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

literal 0
HcmV?d00001

diff --git a/public/solver/SomaSolver.js b/public/solver/SomaSolver.js
deleted file mode 100644
index 0d22f29..0000000
--- a/public/solver/SomaSolver.js
+++ /dev/null
@@ -1,138 +0,0 @@
-import VoxelSpace from "./VoxelSpace.js";
-import SomaSolution from "./SomaSolution.js";
-export default class SomaSolver {
-    constructor(dimension) {
-        this.solutions = [];
-        this.iterations = 0;
-        if (dimension % 1 !== 0 || dimension < 0) {
-            throw new Error("The argument 'dimension' must be a positive whole number");
-        }
-        this.dim = dimension;
-        this.solutionCube = new VoxelSpace(0, [dimension, dimension, dimension], Array(dimension ** 3).fill(0));
-    }
-    async solve(polycubes) {
-        if (polycubes.length === 0) {
-            throw new Error("You must pass at least one polycube to solve the puzzle.");
-        }
-        let cumulativeSize = polycubes.reduce((prev, curr) => prev + curr.size(), 0);
-        if (cumulativeSize !== this.dim ** 3) {
-            throw new Error(`The polycubes passed do not add up to exactly enough units to form a cube of dimension ${this.dim}! Got: ${cumulativeSize}, need: ${this.dim ** 3}`);
-        }
-        this.solutions = [];
-        const combosWithRots = polycubes.slice(1).map(polycube => polycube.getUniqueRotations().map((rot) => rot.getAllPositionsInCube(this.dim)).flat());
-        const combos = [polycubes[0].getAllPositionsInCube(this.dim), ...combosWithRots];
-        console.log(combos.flat().length);
-        this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dim));
-        this.solutions = SomaSolution.filterUnique(this.solutions);
-    }
-    getSolutions() {
-        return this.solutions.slice();
-    }
-    backtrackSolve(workingSolution, polycubes, currentSoln) {
-        const nextCubeGroup = polycubes[0];
-        for (let i = 0; i < nextCubeGroup.length; i++) {
-            const fusionAttempt = workingSolution.plus(nextCubeGroup[i]);
-            if (fusionAttempt) {
-                const nextSoln = currentSoln.clone();
-                nextSoln.addSpace(nextCubeGroup[i]);
-                if (polycubes.length === 1) {
-                    this.solutions.push(nextSoln);
-                    currentSoln = new SomaSolution(this.dim);
-                    return;
-                }
-                else {
-                    this.backtrackSolve(fusionAttempt, polycubes.slice(1), nextSoln);
-                }
-            }
-        }
-    }
-}
-
-class SomaSolution {
-    constructor(dim) {
-        if (dim < 0 || dim % 1 !== 0) {
-            throw new Error("Dimension must be a whole positive integer!");
-        }
-        this.dim = dim;
-        this.solutionSpaces = [];
-    }
-    static filterUnique(solutions) {
-        if (solutions.length === 0) {
-            return [];
-        }
-        const uniqueSolns = [solutions[0]];
-        for (const solution of solutions) {
-            let foundMatch = false;
-            for (const rotation of solution.getUniqueRotations()) {
-                let end = uniqueSolns.length;
-                for (let i = 0; i < end; i++) {
-                    if (rotation.matches(uniqueSolns[i])) {
-                        foundMatch = true;
-                    }
-                }
-            }
-            if (!foundMatch) {
-                uniqueSolns.push(solution);
-            }
-        }
-        return uniqueSolns;
-    }
-    getUniqueRotations() {
-        if (this.solutionSpaces.length === 0) {
-            return [];
-        }
-        const result = [];
-        const allRots = this.solutionSpaces.map(space => space.getAllRotations());
-        for (let i = 0; i < allRots[0].length; i++) {
-            const solnRot = new SomaSolution(this.dim);
-            allRots.forEach(rotGroup => solnRot.addSpace(rotGroup[i]));
-            result.push(solnRot);
-        }
-        return result;
-    }
-    matches(solution) {
-        for (let i = 0; i < this.solutionSpaces.length; i++) {
-            if (!this.solutionSpaces[i].matches(solution.solutionSpaces[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    addSpace(space) {
-        this.solutionSpaces.push(space);
-    }
-    print() {
-        let accum = "";
-        console.log("---");
-        for (let x = 0; x < this.dim; x++) {
-            for (let y = 0; y < this.dim; y++) {
-                for (let z = 0; z < this.dim; z++) {
-                    for (const space of this.solutionSpaces) {
-                        if (space.at(x, y, z)) {
-                            accum += space.getId();
-                        }
-                    }
-                }
-                console.log(accum);
-                accum = "";
-            }
-            if (x !== this.dim - 1) {
-                console.log("-");
-            }
-        }
-        console.log("---");
-    }
-    at(x, y, z) {
-        for (const space of this.solutionSpaces) {
-            if (space.at(x, y, z)) {
-                return space.getId();
-            }
-        }
-        return 0;
-    }
-    clone() {
-        const clone = new SomaSolution(this.dim);
-        clone.solutionSpaces = this.solutionSpaces.slice();
-        return clone;
-    }
-}
diff --git a/public/solver/false b/public/solver/false
new file mode 100644
index 0000000..1d4f3ff
--- /dev/null
+++ b/public/solver/false
@@ -0,0 +1 @@
+{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/SomaSolver.ts","assembly/VoxelSpace.ts","~lib/util/error.ts","~lib/rt.ts","~lib/memory.ts","~lib/util/memory.ts","~lib/util/math.ts","~lib/math.ts","~lib/util/number.ts","~lib/util/string.ts","~lib/array.ts","assembly/index.ts","assembly/SomaSolution.ts","~lib/builtins.ts","~lib/arraybuffer.ts","~lib/typedarray.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./main.wasm","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │                           MM info                             │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │                              ...                              │\n@unmanaged export class BLOCK {\n  /** Memory manager info. */\n  mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof<BLOCK>();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │                     Memory manager block                      │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │                            GC info                            │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │                            GC info                            │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │                            RT id                              │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │                            RT size                            │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │                              ...                              │\n@unmanaged export class OBJECT extends BLOCK {\n  /** Garbage collector info. */\n  gcInfo: u32;\n  /** Garbage collector info. */\n  gcInfo2: u32;\n  /** Runtime class id. */\n  rtId: u32;\n  /** Runtime object size. */\n  rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof<OBJECT>() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ |                    FL                       │ SB = SL + AL  │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB)  [12]: < 1M\n// [01]: < 512B       [13]: < 2M\n// [02]: < 1K         [14]: < 4M\n// [03]: < 2K         [15]: < 8M\n// [04]: < 4K         [16]: < 16M\n// [05]: < 8K         [17]: < 32M\n// [06]: < 16K        [18]: < 64M\n// [07]: < 32K        [19]: < 128M\n// [08]: < 64K        [20]: < 256M\n// [09]: < 128K       [21]: < 512M\n// [10]: < 256K       [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤            ┐\n// │                          size                             │L│F│ ◄─┐ info   overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡   │        ┘\n// │                        if free: ◄ prev                        │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤   │\n// │                        if free: next ►                        │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤   │\n// │                             ...                               │   │ >= 0\n// ├───────────────────────────────────────────────────────────────┤   │\n// │                        if free: back ▲                        │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n  /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n  prev: Block | null;\n  /** Next free block, if any. Only valid if free, otherwise part of payload. */\n  next: Block | null;\n\n  // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof<usize>() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n  return load<Block>(changetype<usize>(block) - sizeof<usize>());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n  return changetype<Block>(changetype<usize>(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤          ┐\n// │        0        |           flMap                            S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡      │\n// │                           slMap[0] S                          │ ◄─┐  │\n// ├───────────────────────────────────────────────────────────────┤   │  │\n// │                           slMap[1]                            │ ◄─┤  │\n// ├───────────────────────────────────────────────────────────────┤  u32 │\n// │                           slMap[22]                           │ ◄─┘  │\n// ╞═══════════════════════════════════════════════════════════════╡    usize\n// │                            head[0]                            │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤      │\n// │                              ...                              │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤      │\n// │                           head[367]                           │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡      │\n// │                             tail                              │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘   SIZE   ┘\n// S: Small blocks map\n@unmanaged class Root {\n  /** First level bitmap. */\n  flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof<usize>();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof<u32>());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof<usize>();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof<usize>();\n\n// @ts-ignore: decorator\n@lazy export var ROOT: Root;\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n  return load<u32>(\n    changetype<usize>(root) + (fl << alignof<u32>()),\n    SL_START\n  );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n  store<u32>(\n    changetype<usize>(root) + (fl << alignof<u32>()),\n    slMap,\n    SL_START\n  );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n  return load<Block>(\n    changetype<usize>(root) + (((fl << SL_BITS) + <usize>sl) << alignof<usize>()),\n    HL_START\n  );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n  store<Block | null>(\n    changetype<usize>(root) + (((fl << SL_BITS) + <usize>sl) << alignof<usize>()),\n    head,\n    HL_START\n  );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n  return load<Block>(\n    changetype<usize>(root),\n    HL_END\n  );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n  store<Block>(\n    changetype<usize>(root),\n    tail,\n    HL_END\n  );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n  if (DEBUG) assert(block); // cannot be null\n  var blockInfo = block.mmInfo;\n  if (DEBUG) assert(blockInfo & FREE); // must be free\n\n  var right = GETRIGHT(block);\n  var rightInfo = right.mmInfo;\n\n  // merge with right block if also free\n  if (rightInfo & FREE) {\n    removeBlock(root, right);\n    block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n    right = GETRIGHT(block);\n    rightInfo = right.mmInfo;\n    // 'back' is set below\n  }\n\n  // merge with left block if also free\n  if (blockInfo & LEFTFREE) {\n    let left = GETFREELEFT(block);\n    let leftInfo = left.mmInfo;\n    if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n    removeBlock(root, left);\n    block = left;\n    block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n    // 'back' is set below\n  }\n\n  right.mmInfo = rightInfo | LEFTFREE;\n  // reference to right is no longer used now, hence rightInfo is not synced\n\n  // we now know the size of the block\n  var size = blockInfo & ~TAGS_MASK;\n  if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n  if (DEBUG) assert(changetype<usize>(block) + BLOCK_OVERHEAD + size == changetype<usize>(right)); // must match\n\n  // set 'back' to itself at the end of block\n  store<Block>(changetype<usize>(right) - sizeof<usize>(), block);\n\n  // mapping_insert\n  var fl: usize, sl: u32;\n  if (size < SB_SIZE) {\n    fl = 0;\n    sl = <u32>(size >> AL_BITS);\n  } else {\n    const inv: usize = sizeof<usize>() * 8 - 1;\n    let boundedSize = min(size, BLOCK_MAXSIZE);\n    fl = inv - clz<usize>(boundedSize);\n    sl = <u32>((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n    fl -= SB_BITS - 1;\n  }\n  if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n  // perform insertion\n  var head = GETHEAD(root, fl, sl);\n  block.prev = null;\n  block.next = head;\n  if (head) head.prev = block;\n  SETHEAD(root, fl, sl, block);\n\n  // update first and second level maps\n  root.flMap |= (1 << fl);\n  SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n  var blockInfo = block.mmInfo;\n  if (DEBUG) assert(blockInfo & FREE); // must be free\n  var size = blockInfo & ~TAGS_MASK;\n  if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n  // mapping_insert\n  var fl: usize, sl: u32;\n  if (size < SB_SIZE) {\n    fl = 0;\n    sl = <u32>(size >> AL_BITS);\n  } else {\n    const inv: usize = sizeof<usize>() * 8 - 1;\n    let boundedSize = min(size, BLOCK_MAXSIZE);\n    fl = inv - clz<usize>(boundedSize);\n    sl = <u32>((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n    fl -= SB_BITS - 1;\n  }\n  if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n  // link previous and next free block\n  var prev = block.prev;\n  var next = block.next;\n  if (prev) prev.next = next;\n  if (next) next.prev = prev;\n\n  // update head if we are removing it\n  if (block == GETHEAD(root, fl, sl)) {\n    SETHEAD(root, fl, sl, next);\n\n    // clear second level map if head is empty now\n    if (!next) {\n      let slMap = GETSL(root, fl);\n      SETSL(root, fl, slMap &= ~(1 << sl));\n\n      // clear first level map if second level is empty now\n      if (!slMap) root.flMap &= ~(1 << fl);\n    }\n  }\n  // note: does not alter left/back because it is likely that splitting\n  // is performed afterwards, invalidating those changes. so, the caller\n  // must perform those updates.\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n  // size was already asserted by caller\n\n  // mapping_search\n  var fl: usize, sl: u32;\n  if (size < SB_SIZE) {\n    fl = 0;\n    sl = <u32>(size >> AL_BITS);\n  } else {\n    const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n    const inv: usize = sizeof<usize>() * 8 - 1;\n    const invRound = inv - SL_BITS;\n    let requestSize = size < halfMaxSize\n      ? size + (1 << (invRound - clz<usize>(size))) - 1\n      : size;\n    fl = inv - clz<usize>(requestSize);\n    sl = <u32>((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n    fl -= SB_BITS - 1;\n  }\n  if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n  // search second level\n  var slMap = GETSL(root, fl) & (~0 << sl);\n  var head: Block | null = null;\n  if (!slMap) {\n    // search next larger first level\n    let flMap = root.flMap & (~0 << (fl + 1));\n    if (!flMap) {\n      head = null;\n    } else {\n      fl = ctz<usize>(flMap);\n      slMap = GETSL(root, fl);\n      if (DEBUG) assert(slMap);  // can't be zero if fl points here\n      head = GETHEAD(root, fl, ctz<u32>(slMap));\n    }\n  } else {\n    head = GETHEAD(root, fl, ctz<u32>(slMap));\n  }\n  return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n  // size was already asserted by caller\n\n  var blockInfo = block.mmInfo;\n  if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n  // split if the block can hold another MINSIZE block incl. overhead\n  var remaining = (blockInfo & ~TAGS_MASK) - size;\n  if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n    block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n    let spare = changetype<Block>(changetype<usize>(block) + BLOCK_OVERHEAD + size);\n    spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n    insertBlock(root, spare); // also sets 'back'\n\n  // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n  } else {\n    block.mmInfo = blockInfo & ~FREE;\n    GETRIGHT(block).mmInfo &= ~LEFTFREE;\n  }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, end: usize): bool {\n  if (DEBUG) assert(start <= end); // must be valid\n  start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n  end &= ~AL_MASK;\n\n  var tail = GETTAIL(root);\n  var tailInfo: usize = 0;\n  if (tail) { // more memory\n    if (DEBUG) assert(start >= changetype<usize>(tail) + BLOCK_OVERHEAD);\n\n    // merge with current tail if adjacent\n    const offsetToTail = AL_SIZE;\n    if (start - offsetToTail == changetype<usize>(tail)) {\n      start -= offsetToTail;\n      tailInfo = tail.mmInfo;\n    } else {\n      // We don't do this, but a user might `memory.grow` manually\n      // leading to non-adjacent pages managed by TLSF.\n    }\n\n  } else if (DEBUG) { // first memory\n    assert(start >= changetype<usize>(root) + ROOT_SIZE); // starts after root\n  }\n\n  // check if size is large enough for a free block and the tail block\n  var size = end - start;\n  if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n    return false;\n  }\n\n  // left size is total minus its own and the zero-length tail's header\n  var leftSize = size - 2 * BLOCK_OVERHEAD;\n  var left = changetype<Block>(start);\n  left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n  left.prev = null;\n  left.next = null;\n\n  // tail is a zero-length used block\n  tail = changetype<Block>(start + BLOCK_OVERHEAD + leftSize);\n  tail.mmInfo = 0 | LEFTFREE;\n  SETTAIL(root, tail);\n\n  insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n  return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n  if (ASC_LOW_MEMORY_LIMIT) {\n    unreachable();\n    return;\n  }\n  // Here, both rounding performed in searchBlock ...\n  const halfMaxSize = BLOCK_MAXSIZE >> 1;\n  if (size < halfMaxSize) { // don't round last fl\n    const invRound = (sizeof<usize>() * 8 - 1) - SL_BITS;\n    size += (1 << (invRound - clz<usize>(size))) - 1;\n  }\n  // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n  // to merge with the tail block, that's one time, otherwise it's two times.\n  var pagesBefore = memory.size();\n  size += BLOCK_OVERHEAD << usize((<usize>pagesBefore << 16) - BLOCK_OVERHEAD != changetype<usize>(GETTAIL(root)));\n  var pagesNeeded = <i32>(((size + 0xffff) & ~0xffff) >>> 16);\n  var pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n  if (memory.grow(pagesWanted) < 0) {\n    if (memory.grow(pagesNeeded) < 0) unreachable();\n  }\n  var pagesAfter = memory.size();\n  addMemory(root, <usize>pagesBefore << 16, <usize>pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n  // Size must be large enough and aligned minus preceeding overhead\n  return size <= BLOCK_MINSIZE\n    ? BLOCK_MINSIZE\n    : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n  if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n  return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n  if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n  var rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n  var pagesBefore = memory.size();\n  var pagesNeeded = <i32>((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n  if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n  var root = changetype<Root>(rootOffset);\n  root.flMap = 0;\n  SETTAIL(root, changetype<Block>(0));\n  for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n    SETSL(root, fl, 0);\n    for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n      SETHEAD(root, fl, sl, null);\n    }\n  }\n  var memStart = rootOffset + ROOT_SIZE;\n  if (ASC_LOW_MEMORY_LIMIT) {\n    const memEnd = <usize>ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n    if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n    else unreachable(); // low memory limit already exceeded\n  } else {\n    addMemory(root, memStart, memory.size() << 16);\n  }\n  ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n  var payloadSize = prepareSize(size);\n  var block = searchBlock(root, payloadSize);\n  if (!block) {\n    growMemory(root, payloadSize);\n    block = changetype<Block>(searchBlock(root, payloadSize));\n    if (DEBUG) assert(block); // must be found now\n  }\n  if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n  removeBlock(root, <Block>block);\n  prepareBlock(root, <Block>block, payloadSize);\n  if (isDefined(ASC_RTRACE)) onalloc(block);\n  return <Block>block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n  var payloadSize = prepareSize(size);\n  var blockInfo = block.mmInfo;\n  var blockSize = blockInfo & ~TAGS_MASK;\n\n  // possibly split and update runtime size if it still fits\n  if (payloadSize <= blockSize) {\n    prepareBlock(root, block, payloadSize);\n    if (isDefined(ASC_RTRACE)) {\n      if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n    }\n    return block;\n  }\n\n  // merge with right free block if merger is large enough\n  var right = GETRIGHT(block);\n  var rightInfo = right.mmInfo;\n  if (rightInfo & FREE) {\n    let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n    if (mergeSize >= payloadSize) {\n      removeBlock(root, right);\n      block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n      prepareBlock(root, block, payloadSize);\n      if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n      return block;\n    }\n  }\n\n  // otherwise move the block\n  return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n  var newBlock = allocateBlock(root, newSize);\n  memory.copy(changetype<usize>(newBlock) + BLOCK_OVERHEAD, changetype<usize>(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n  if (changetype<usize>(block) >= __heap_base) {\n    if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n    freeBlock(root, block);\n  }\n  return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n  if (isDefined(ASC_RTRACE)) onfree(block);\n  block.mmInfo = block.mmInfo | FREE;\n  insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n  var block = changetype<Block>(ptr - BLOCK_OVERHEAD);\n  assert(\n    ptr != 0 && !(ptr & AL_MASK) &&  // must exist and be aligned\n    !(block.mmInfo & FREE)           // must be used\n  );\n  return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n  if (!ROOT) initialize();\n  return changetype<usize>(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n  if (!ROOT) initialize();\n  return (ptr < __heap_base\n    ? changetype<usize>(moveBlock(ROOT, checkUsedBlock(ptr), size))\n    : changetype<usize>(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n  ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n  if (ptr < __heap_base) return;\n  if (!ROOT) initialize();\n  freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │                             count                             │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │                      Typeinfo#flags [id=0]                    │ id < count\n// ├ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┤\n// │                      Typeinfo#base  [id=0]                    │\n// ├───────────────────────────────────────────────────────────────┤\n// │                              ...                              │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n  /** Flags describing the shape of this class type. */\n  flags: TypeinfoFlags = TypeinfoFlags.NONE;\n  /** Base class id or `0` if none. */\n  base: u32 = 0;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n  /** No specific flags. */\n  NONE = 0,\n  /** Type is an `ArrayBufferView`. */\n  ARRAYBUFFERVIEW = 1 << 0,\n  /** Type is an `Array`. */\n  ARRAY = 1 << 1,\n  /** Type is a `StaticArray`. */\n  STATICARRAY = 1 << 2,\n  /** Type is a `Set`. */\n  SET = 1 << 3,\n  /** Type is a `Map`. */\n  MAP = 1 << 4,\n  /** Type has no outgoing pointers. */\n  POINTERFREE = 1 << 5,\n  /** Value alignment of 1 byte. */\n  VALUE_ALIGN_0 = 1 << 6,\n  /** Value alignment of 2 bytes. */\n  VALUE_ALIGN_1 = 1 << 7,\n  /** Value alignment of 4 bytes. */\n  VALUE_ALIGN_2 = 1 << 8,\n  /** Value alignment of 8 bytes. */\n  VALUE_ALIGN_3 = 1 << 9,\n  /** Value alignment of 16 bytes. */\n  VALUE_ALIGN_4 = 1 << 10,\n  /** Value is a signed type. */\n  VALUE_SIGNED = 1 << 11,\n  /** Value is a float type. */\n  VALUE_FLOAT = 1 << 12,\n  /** Value type is nullable. */\n  VALUE_NULLABLE = 1 << 13,\n  /** Value type is managed. */\n  VALUE_MANAGED = 1 << 14,\n  /** Key alignment of 1 byte. */\n  KEY_ALIGN_0 = 1 << 15,\n  /** Key alignment of 2 bytes. */\n  KEY_ALIGN_1 = 1 << 16,\n  /** Key alignment of 4 bytes. */\n  KEY_ALIGN_2 = 1 << 17,\n  /** Key alignment of 8 bytes. */\n  KEY_ALIGN_3 = 1 << 18,\n  /** Key alignment of 16 bytes. */\n  KEY_ALIGN_4 = 1 << 19,\n  /** Key is a signed type. */\n  KEY_SIGNED = 1 << 20,\n  /** Key is a float type. */\n  KEY_FLOAT = 1 << 21,\n  /** Key type is nullable. */\n  KEY_NULLABLE = 1 << 22,\n  /** Key type is managed. */\n  KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color       │ Meaning                                         │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE*      │ Unprocessed                                     │\n// │ BLACK*      │ Processed                                       │\n// │ GRAY        │ Processed with unprocessed children             │\n// │ TRANSPARENT │ Manually pinned (always reachable)              │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy var white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy var total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy var state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy var fromSpace = initLazy(changetype<Object>(memory.data(offsetof<Object>())));\n// @ts-ignore: decorator\n@lazy var toSpace = initLazy(changetype<Object>(memory.data(offsetof<Object>())));\n// @ts-ignore: decorator\n@lazy var pinSpace = initLazy(changetype<Object>(memory.data(offsetof<Object>())));\n// @ts-ignore: decorator\n@lazy var iter: Object; // null\n\nfunction initLazy(space: Object): Object {\n  space.nextWithColor = changetype<usize>(space);\n  space.prev = space;\n  return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │                      Memory manager block                     │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │                              next                         │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │                              prev                             │\n// ├───────────────────────────────────────────────────────────────┤\n// │                              rtId                             │\n// ├───────────────────────────────────────────────────────────────┤\n// │                              rtSize                           │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │                               ...                             │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n  /** Pointer to the next object with color flags stored in the alignment bits. */\n  nextWithColor: usize; // *u32\n  /** Pointer to the previous object. */\n  prev: Object; // *u32\n  /** Runtime id. */\n  rtId: u32;\n  /** Runtime size. */\n  rtSize: u32;\n\n  /** Gets the pointer to the next object. */\n  get next(): Object {\n    return changetype<Object>(this.nextWithColor & ~COLOR_MASK);\n  }\n\n  /** Sets the pointer to the next object. */\n  set next(obj: Object) {\n    this.nextWithColor = changetype<usize>(obj) | (this.nextWithColor & COLOR_MASK);\n  }\n\n  /** Gets this object's color. */\n  get color(): i32 {\n    return i32(this.nextWithColor & COLOR_MASK);\n  }\n\n  /** Sets this object's color. */\n  set color(color: i32) {\n    this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n  }\n\n  /** Gets the size of this object in memory. */\n  get size(): usize {\n    return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n  }\n\n  /** Tests if this object is pointerfree. */\n  get isPointerfree(): bool {\n    var rtId = this.rtId;\n    return rtId <= idof<string>() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n  }\n\n  /** Unlinks this object from its list. */\n  unlink(): void {\n    var next = this.next;\n    if (next == null) {\n      if (DEBUG) assert(this.prev == null && changetype<usize>(this) < __heap_base);\n      return; // static data not yet linked\n    }\n    var prev = this.prev;\n    if (DEBUG) assert(prev);\n    next.prev = prev;\n    prev.next = next;\n  }\n\n  /** Links this object to the specified list, with the given color. */\n  linkTo(list: Object, withColor: i32): void {\n    let prev = list.prev;\n    this.nextWithColor = changetype<usize>(list) | withColor;\n    this.prev = prev;\n    prev.next = this;\n    list.prev = this;\n  }\n\n  /** Marks this object as gray, that is reachable with unscanned children. */\n  makeGray(): void {\n    if (this == iter) iter = assert(this.prev);\n    this.unlink();\n    this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n  }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n  __visit_globals(cookie);\n  var pn = pinSpace;\n  var iter = pn.next;\n  while (iter != pn) {\n    if (DEBUG) assert(iter.color == transparent);\n    __visit_members(changetype<usize>(iter) + TOTAL_OVERHEAD, cookie);\n    iter = iter.next;\n  }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n  var ptr = __stack_pointer;\n  while (ptr < __heap_base) {\n    __visit(load<usize>(ptr), cookie);\n    ptr += sizeof<usize>();\n  }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n  // Magic constants responsible for pause times. Obtained experimentally\n  // using the compiler compiling itself. 2048 budget pro run by default.\n  const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n  const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n  var obj: Object;\n  switch (state) {\n    case STATE_IDLE: {\n      state = STATE_MARK;\n      visitCount = 0;\n      visitRoots(VISIT_SCAN);\n      iter = toSpace;\n      return visitCount * MARKCOST;\n    }\n    case STATE_MARK: {\n      let black = i32(!white);\n      obj = iter.next;\n      while (obj != toSpace) {\n        iter = obj;\n        if (obj.color != black) { // skip already-blacks (pointerfree)\n          obj.color = black;\n          visitCount = 0;\n          __visit_members(changetype<usize>(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n          return visitCount * MARKCOST;\n        }\n        obj = obj.next;\n      }\n      visitCount = 0;\n      visitRoots(VISIT_SCAN);\n      obj = iter.next;\n      if (obj == toSpace) {\n        visitStack(VISIT_SCAN);\n        obj = iter.next;\n        while (obj != toSpace) {\n          if (obj.color != black) {\n            obj.color = black;\n            __visit_members(changetype<usize>(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n          }\n          obj = obj.next;\n        }\n        let from = fromSpace;\n        fromSpace = toSpace;\n        toSpace = from;\n        white = black;\n        iter = from.next;\n        state = STATE_SWEEP;\n      }\n      return visitCount * MARKCOST;\n    }\n    case STATE_SWEEP: {\n      obj = iter;\n      if (obj != toSpace) {\n        iter = obj.next;\n        if (DEBUG) assert(obj.color == i32(!white)); // old white\n        free(obj);\n        return SWEEPCOST;\n      }\n      toSpace.nextWithColor = changetype<usize>(toSpace);\n      toSpace.prev = toSpace;\n      state = STATE_IDLE;\n      break;\n    }\n  }\n  return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n  if (changetype<usize>(obj) < __heap_base) {\n    obj.nextWithColor = 0; // may become linked again\n    obj.prev = changetype<Object>(0);\n  } else {\n    total -= obj.size;\n    if (isDefined(__finalize)) {\n      __finalize(changetype<usize>(obj) + TOTAL_OVERHEAD);\n    }\n    __free(changetype<usize>(obj) + BLOCK_OVERHEAD);\n  }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n  if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n  if (total >= threshold) interrupt();\n  var obj = changetype<Object>(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n  obj.rtId = id;\n  obj.rtSize = <u32>size;\n  obj.linkTo(fromSpace, white); // inits next/prev\n  total += obj.size;\n  var ptr = changetype<usize>(obj) + TOTAL_OVERHEAD;\n  // may be visited before being fully initialized, so must fill\n  memory.fill(ptr, 0, size);\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n  var oldObj = changetype<Object>(oldPtr - TOTAL_OVERHEAD);\n  // Update object size if its block is large enough\n  if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n    oldObj.rtSize = <u32>size;\n    return oldPtr;\n  }\n  // If not the same object anymore, we have to move it move it due to the\n  // shadow stack potentially still referencing the old object\n  var newPtr = __new(size, oldObj.rtId);\n  memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n  return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n  // Write barrier is unnecessary if non-incremental\n  if (!childPtr) return;\n  if (DEBUG) assert(parentPtr);\n  var child = changetype<Object>(childPtr - TOTAL_OVERHEAD);\n  if (child.color == white) {\n    let parent = changetype<Object>(parentPtr - TOTAL_OVERHEAD);\n    let parentColor = parent.color;\n    if (parentColor == i32(!white)) {\n      // Maintain the invariant that no black object may point to a white object.\n      if (expectMultiple) {\n        // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n        // Avoids a barrier for subsequent objects stored into the same container.\n        parent.makeGray();\n      } else {\n        // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n        child.makeGray();\n      }\n    } else if (parentColor == transparent && state == STATE_MARK) {\n      // Pinned objects are considered 'black' during the mark phase.\n      child.makeGray();\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@lazy var visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n  if (!ptr) return;\n  let obj = changetype<Object>(ptr - TOTAL_OVERHEAD);\n  if (RTRACE) if (!onvisit(obj)) return;\n  if (obj.color == white) {\n    obj.makeGray();\n    ++visitCount;\n  }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n  if (ptr) {\n    let obj = changetype<Object>(ptr - TOTAL_OVERHEAD);\n    if (obj.color == transparent) {\n      throw new Error(E_ALREADY_PINNED);\n    }\n    obj.unlink(); // from fromSpace\n    obj.linkTo(pinSpace, transparent);\n  }\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n  if (!ptr) return;\n  var obj = changetype<Object>(ptr - TOTAL_OVERHEAD);\n  if (obj.color != transparent) {\n    throw new Error(E_NOT_PINNED);\n  }\n  if (state == STATE_MARK) {\n    // We may be right at the point after marking roots for the second time and\n    // entering the sweep phase, in which case the object would be missed if it\n    // is not only pinned but also a root. Make sure it isn't missed.\n    obj.makeGray();\n  } else {\n    obj.unlink();\n    obj.linkTo(fromSpace, white);\n  }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n  if (TRACE) trace(\"GC (full) at\", 1, total);\n  if (state > STATE_IDLE) {\n    // finish current cycle\n    while (state != STATE_IDLE) step();\n  }\n  // perform a full cycle\n  step();\n  while (state != STATE_IDLE) step();\n  threshold = <usize>(<u64>total * IDLEFACTOR / 100) + GRANULARITY;\n  if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n  if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy var threshold: usize = ((<usize>memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n  if (PROFILE) oninterrupt(total);\n  if (TRACE) trace(\"GC (auto) at\", 1, total);\n  var budget: isize = GRANULARITY * STEPFACTOR / 100;\n  do {\n    budget -= step();\n    if (state == STATE_IDLE) {\n      if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n      threshold = <usize>(<u64>total * IDLEFACTOR / 100) + GRANULARITY;\n      if (PROFILE) onyield(total);\n      return;\n    }\n  } while (budget > 0);\n  if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n  threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n  if (PROFILE) onyield(total);\n}\n","import VoxelSpace from \"./VoxelSpace\";\nimport SomaSolution from \"./SomaSolution\";\n\nexport default class SomaSolver {\n    private solutionCube: VoxelSpace;\n    private dimX: i32;\n    private dimY: i32;\n    private dimZ: i32;\n    private solutions: SomaSolution[] = new Array<SomaSolution>();\n    constructor(dimX: i32, dimY: i32, dimZ: i32) {\n        this.dimX = dimX;\n        this.dimY = dimY;\n        this.dimZ = dimZ;\n        this.solutionCube = new VoxelSpace(0, dimX, dimY, dimZ, 0);\n    }\n\n    solve(polycubes: VoxelSpace[]): void {\n        if (polycubes.length === 0) {\n            throw new Error(\"You must pass at least one polycube to solve the puzzle.\");\n        }\n        this.solutions.splice(0, this.solutions.length);\n        const combosWithRots: VoxelSpace[][] = new Array<Array<VoxelSpace>>();\n        for (let i = 1; i < polycubes.length; i++) {\n            combosWithRots.push(polycubes[i].getAllPermutationsInPrism(this.dimX, this.dimY, this.dimZ));\n        }\n        let combos: VoxelSpace[][] = new Array<Array<VoxelSpace>>();\n        combos.push(polycubes[0].getAllPositionsInPrism(this.dimX, this.dimY, this.dimZ));\n        combos = combos.concat(combosWithRots);\n        this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dimX, this.dimY, this.dimZ));\n        this.solutions = SomaSolution.filterUnique(this.solutions);\n    }\n\n    getSolutions(): SomaSolution[] {\n        return this.solutions.slice(0, this.solutions.length);\n    }\n\n    private backtrackSolve(workingSolution: VoxelSpace, polycubes: VoxelSpace[][], currentSoln: SomaSolution, depth: i32 = 0): void {\n        const nextCubeGroup = polycubes[0];\n        for (let i = 0; i < nextCubeGroup.length; i++) {\n            const fusionAttempt = workingSolution.plus(nextCubeGroup[i]);\n            if (fusionAttempt) {\n                const nextSoln = currentSoln.clone();\n                nextSoln.addSpace(nextCubeGroup[i]);\n                if (polycubes.length == 1) {\n                    this.solutions.push(nextSoln);\n                    currentSoln = new SomaSolution(this.dimX, this.dimY, this.dimZ);\n                    return;\n                } else {\n                    this.backtrackSolve(fusionAttempt, polycubes.slice(1), nextSoln, depth + 1);\n                }\n            }\n        }\n    }\n}","class Extrema {\n    constructor(\n        public xMax: i32,\n        public xMin: i32,\n        public yMax: i32,\n        public yMin: i32,\n        public zMax: i32,\n        public zMin: i32,\n    ) {}\n}\n\nexport default class VoxelSpace {\n    private length: i32;\n    private space: i64;\n    private id: i32;\n    private dimX: i32;\n    private dimY: i32;\n    private dimZ: i32;\n\n    constructor(id: i32, dimx: i32, dimy: i32, dimz: i32, space: i64 = 0, cullEmpty: boolean = false) {\n        this.id = id;\n        this.length = dimx * dimy * dimz;\n        this.dimX = dimx;\n        this.dimY = dimy;\n        this.dimZ = dimz;\n        this.space = space;\n        if (cullEmpty) {\n            this.cullEmptySpace();\n        }\n    }\n\n    getExtrema(): Extrema {\n        const extrema = new Extrema(\n            0,\n            this.dimX,\n            0,\n            this.dimY,\n            0,\n            this.dimZ,\n        );\n        for (let x = 0; x < this.dimX; x++) {\n            for (let y = 0; y < this.dimY; y++) {\n                for (let z = 0; z < this.dimZ; z++) {\n                    const val = this.at(x, y, z);\n                    if (val) {\n                        extrema.xMax = Math.max(extrema.xMax, x) as i32;\n                        extrema.xMin = Math.min(extrema.xMin, x) as i32;\n                        extrema.yMax = Math.max(extrema.yMax, y) as i32;\n                        extrema.yMin = Math.min(extrema.yMin, y) as i32;\n                        extrema.zMax = Math.max(extrema.zMax, z) as i32;\n                        extrema.zMin = Math.min(extrema.zMin, z) as i32;\n                    }\n                }\n            }\n        }\n        return extrema;\n    }\n\n    private cullEmptySpace(): void {\n        const extrema = this.getExtrema();\n        let index: i32 = 0;\n        let newSpace: i64 = 0;\n        for (let x = extrema.xMin; x <= extrema.xMax; x++) {\n            for (let y = extrema.yMin; y <= extrema.yMax; y++) {\n                for (let z = extrema.zMin; z <= extrema.zMax; z++) {\n                    if (this.at(x, y, z)) {\n                        newSpace |= 1 << index;\n                    }\n                    index++;\n                }\n            }\n        }\n        this.dimX = extrema.xMax - extrema.xMin + 1;\n        this.dimY = extrema.yMax - extrema.yMin + 1;\n        this.dimZ = extrema.zMax - extrema.zMin + 1;\n        this.space = newSpace;\n    }\n\n    getId(): i32 {\n        return this.id;\n    }\n\n    getUniqueRotations(): VoxelSpace[] {\n        const rotations: VoxelSpace[] = new Array<VoxelSpace>();\n        const refSpace = this.clone();\n        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getXAxisSpins());\n        refSpace.rot90Y();\n        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getXAxisSpins());\n        refSpace.rot90Y();\n        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getXAxisSpins());\n        refSpace.rot90Y();\n        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getXAxisSpins());\n        refSpace.rot90Z();\n        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getXAxisSpins());\n        refSpace.rot90Z();\n        refSpace.rot90Z();\n        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getXAxisSpins());\n        return rotations;\n    }\n\n    getAllRotations(): VoxelSpace[] {\n        let rotations: VoxelSpace[] = new Array<VoxelSpace>();\n        const refSpace = this.clone();\n        rotations = rotations.concat(refSpace.getXAxisSpins());\n        refSpace.rot90Y();\n        rotations = rotations.concat(refSpace.getXAxisSpins());\n        refSpace.rot90Y();\n        rotations = rotations.concat(refSpace.getXAxisSpins());\n        refSpace.rot90Y();\n        rotations = rotations.concat(refSpace.getXAxisSpins());\n        refSpace.rot90Z();\n        rotations = rotations.concat(refSpace.getXAxisSpins());\n        refSpace.rot90Z();\n        refSpace.rot90Z();\n        rotations = rotations.concat(refSpace.getXAxisSpins());\n        return rotations;\n    }\n\n    protected static pushNewUniqueSpaces(existingSpaces: VoxelSpace[], newSpaces: VoxelSpace[]): void {\n        for (let iNew = 0; iNew < newSpaces.length; iNew++) {\n            let matchFound = false;\n            for (let iExisting = 0; iExisting < existingSpaces.length; iExisting++) {\n                if (newSpaces[iNew].matches(existingSpaces[iExisting])) {\n                    matchFound = true;\n                    break;\n                }\n            }\n            if (!matchFound) {\n                existingSpaces.push(newSpaces[iNew]);\n            }\n        }\n    }\n\n    getAllPositionsInPrism(cubeDimX: i32, cubeDimY: i32, cubeDimZ: i32): VoxelSpace[] {\n        const cubePositions: VoxelSpace[] = [];\n        if (this.dimX > cubeDimX || this.dimY > cubeDimY || this.dimZ > cubeDimZ) {\n            return cubePositions;\n        }\n        for (let x = 0; x < (cubeDimX - this.dimX + 1); x++) {\n            for (let y = 0; y < (cubeDimY - this.dimY + 1); y++) {\n                for (let z = 0; z < (cubeDimZ - this.dimZ + 1); z++) {\n                    const cubePos = new VoxelSpace(this.id, cubeDimX, cubeDimY, cubeDimZ);\n                    for (let posX = 0; posX < this.dimX; posX++) {\n                        for (let posY = 0; posY < this.dimY; posY++) {\n                            for (let posZ = 0; posZ < this.dimZ; posZ++) {\n                                cubePos.set(x + posX, y + posY, z + posZ, this.at(posX, posY, posZ));\n                            }\n                        }\n                    }\n                    cubePositions.push(cubePos);\n                }\n            }\n        }\n        return cubePositions;\n    }\n\n    matches(space: VoxelSpace): boolean {\n        if (space.dimX !== this.dimX) {\n            return false;\n        }\n        if (space.dimY !== this.dimY) {\n            return false;\n        }\n        if (space.dimZ !== this.dimZ) {\n            return false;\n        }\n        return this.space == space.getRaw();\n    }\n\n    clone(): VoxelSpace {\n        return new VoxelSpace(this.id, this.dimX, this.dimY, this.dimZ, this.getRaw());\n    }\n\n    private getXAxisSpins(): VoxelSpace[] {\n        const rotations: Array<VoxelSpace> = new Array<VoxelSpace>();\n        rotations.push(this.clone());\n        for (let i = 0; i < 3; i++) {\n            rotations.push(rotations[i].rotated90X());\n        }\n        return rotations;\n    }\n\n    getRaw(): i64 {\n        return this.space;\n    }\n\n    // [1, 0,  0]   [x]   [ x]\n    // [0, 0, -1] * [y] = [-z]\n    // [0, 1,  0]   [z]   [ y]\n    private newIndexRotX(x: i32, y: i32, z: i32): i32 {\n        return this.dimZ * this.dimY * x + this.dimY * (this.dimZ - 1 - z) + y;\n    }\n\n    // [ 0, 0, 1]   [x]   [ z]\n    // [ 0, 1, 0] * [y] = [ y]\n    // [-1, 0, 0]   [z]   [-x]\n    private newIndexRotY(x: i32, y: i32, z: i32): i32 {\n        return this.dimY * this.dimX * z + this.dimX * y + (this.dimX - 1 - x);\n    }\n\n    // [0, -1, 0]     [x]   [-y]\n    // [1,  0, 0]  *  [y] = [ x]\n    // [0,  0, 1]     [z]   [ z]\n    private newIndexRotZ(x: i32, y: i32, z: i32): i32 {\n        return this.dimX * this.dimZ * (this.dimY - 1 - y) + this.dimZ * x + z;\n    }\n\n    at(x: i32, y: i32, z: i32): boolean {\n        const mask = 1 << (this.dimY * this.dimZ * x + this.dimZ * y + z);\n        return (this.space & mask) !== 0;\n    }\n\n    toggle(x: i32, y: i32, z: i32): void {\n        const mask = 1 << this.dimY * this.dimZ * x + this.dimZ * y + z;\n        this.space ^= mask;\n    }\n\n    set(x: i32, y: i32, z: i32, val: boolean): void {\n        const mask = 1 << this.dimY * this.dimZ * x + this.dimZ * y + z;\n        if (val) {\n            this.space |= mask;\n        } else {\n            this.space &= ~mask;\n        }\n    }\n\n    rotated90X(): VoxelSpace {\n        let newSpace = 0;\n        for (let x = 0; x < this.dimX; x++) {\n            for (let y = 0; y < this.dimY; y++) {\n                for (let z = 0; z < this.dimZ; z++) {\n                    if (this.at(x, y, z)) {\n                        newSpace |= 1 << this.newIndexRotX(x, y, z);\n                    }\n                }\n            }\n        }\n        return new VoxelSpace(this.id, this.dimX, this.dimZ, this.dimY, newSpace);\n    }\n\n    rotated90Y(): VoxelSpace {\n        let newSpace = 0;\n        for (let x = 0; x < this.dimX; x++) {\n            for (let y = 0; y < this.dimY; y++) {\n                for (let z = 0; z < this.dimZ; z++) {\n                    if (this.at(x, y, z)) {\n                        newSpace |= 1 << this.newIndexRotY(x, y, z);\n                    }\n                }\n            }\n        }\n        return new VoxelSpace(this.id, this.dimZ, this.dimY, this.dimX, newSpace);\n    }\n\n    rotated90Z(): VoxelSpace {\n        let newSpace = 0;\n        for (let x = 0; x < this.dimX; x++) {\n            for (let y = 0; y < this.dimY; y++) {\n                for (let z = 0; z < this.dimZ; z++) {\n                    if (this.at(x, y, z)) {\n                        newSpace |= 1 << this.newIndexRotZ(x, y, z);\n                    }\n                }\n            }\n        }\n        return new VoxelSpace(this.id, this.dimY, this.dimX, this.dimZ, newSpace);\n    }\n\n    rot90X(): void {\n        const rot = this.rotated90X();\n        this.space = rot.getRaw();\n        this.dimX = rot.dimX;\n        this.dimY = rot.dimY;\n        this.dimZ = rot.dimZ;\n    }\n\n    rot90Y(): void {\n        const rot = this.rotated90Y();\n        this.space = rot.getRaw();\n        this.dimX = rot.dimX;\n        this.dimY = rot.dimY;\n        this.dimZ = rot.dimZ;\n    }\n\n    rot90Z(): void {\n        const rot = this.rotated90Z();\n        this.space = rot.getRaw();\n        this.dimX = rot.dimX;\n        this.dimY = rot.dimY;\n        this.dimZ = rot.dimZ;\n    }\n\n    plus(space: VoxelSpace): VoxelSpace | null {\n        const otherSpace = space.getRaw();\n        if ((this.space | otherSpace) == (this.space ^ otherSpace)) {\n            return new VoxelSpace(this.id, this.dimX, this.dimY, this.dimZ, otherSpace | this.space);\n        }\n        return null;\n    }\n\n    size(): i32 {\n        let size = 0;\n        for (let x = 0; x < this.dimX; x++) {\n            for (let y = 0; y < this.dimY; y++) {\n                for (let z = 0; z < this.dimZ; z++) {\n                    if (this.at(x, y, z)) {\n                        size++;\n                    }\n                }\n            }\n        }\n        return size;\n    }\n\n    getAllPermutationsInPrism(prismDimX: i32, prismDimY: i32, prismDimZ: i32): VoxelSpace[] {\n        const rotations = this.getUniqueRotations();\n        let result = new Array<VoxelSpace>();\n        for (let i = 0; i < rotations.length; i++) {\n            result = result.concat(rotations[i].getAllPositionsInPrism(prismDimX, prismDimY, prismDimZ));\n        }\n        return result;\n    }\n}","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ILLEGALGENTYPE: string = \"Illegal generic type\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { OBJECT, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n  var ptr = __rtti_base;\n  if (id > load<u32>(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n  return changetype<Typeinfo>(ptr + sizeof<u32>() + id * offsetof<Typeinfo>()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __instanceof(ptr: usize, classId: u32): bool { // keyword\n  var id = changetype<OBJECT>(ptr - TOTAL_OVERHEAD).rtId;\n  var rttiBase = __rtti_base;\n  if (id <= load<u32>(rttiBase)) {\n    do if (id == classId) return true;\n    while (id = changetype<Typeinfo>(rttiBase + sizeof<u32>() + id * offsetof<Typeinfo>()).base);\n  }\n  return false;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n  var buffer = __new(size, id);\n  if (data) memory.copy(buffer, data, size);\n  return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n  var bufferSize = <usize>length << alignLog2;\n  // make sure `buffer` is tracked by the shadow stack\n  var buffer = changetype<ArrayBuffer>(__newBuffer(bufferSize, idof<ArrayBuffer>(), data));\n  // ...since allocating the array may trigger GC steps\n  var array = __new(offsetof<i32[]>(), id);\n  store<usize>(array, changetype<usize>(buffer), offsetof<ArrayBufferView>(\"buffer\"));\n  __link(array, changetype<usize>(buffer), false);\n  store<usize>(array, changetype<usize>(buffer), offsetof<ArrayBufferView>(\"dataStart\"));\n  store<i32>(array, bufferSize, offsetof<ArrayBufferView>(\"byteLength\"));\n  store<i32>(array, length, offsetof<i32[]>(\"length_\"));\n  return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n  return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n  /** Gets the size of the memory in pages. */\n  // @ts-ignore: decorator\n  @builtin\n  export declare function size(): i32;\n\n  /** Grows the memory by the given size in pages and returns the previous size in pages. */\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function grow(pages: i32): i32;\n\n  /** Fills a section in memory with the specified byte value. */\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export function fill(dst: usize, c: u8, n: usize): void {\n    memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n  }\n\n  /** Copies a section of memory to another. Has move semantics. */\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export function copy(dst: usize, src: usize, n: usize): void {\n    memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n  }\n\n  /** Initializes a memory segment. */\n  // @ts-ignore: decorator\n  @unsafe\n  export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n    throw new Error(E_NOTIMPLEMENTED);\n  }\n\n  /** Drops a memory segment. */\n  // @ts-ignore: decorator\n  @unsafe\n  export function drop(segmentIndex: u32): void {\n    throw new Error(E_NOTIMPLEMENTED);\n  }\n\n  /** Repeats a section of memory at a specific address. */\n  // @ts-ignore: decorator\n  @unsafe\n  export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n    var index: usize = 0;\n    var total = srcLength * count;\n    while (index < total) {\n      memory.copy(dst + index, src, srcLength);\n      index += srcLength;\n    }\n  }\n\n  /** Compares a section of memory to another. */\n  // @ts-ignore: decorator\n  @inline\n  export function compare(vl: usize, vr: usize, n: usize): i32 {\n    return memcmp(vl, vr, n);\n  }\n\n  /** Gets a pointer to a static chunk of memory of the given size. */\n  // @ts-ignore: decorator\n  @builtin\n  export declare function data<T>(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare var __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n  /** Allocates a chunk of memory of at least the specified size. */\n  // @ts-ignore: decorator\n  @unsafe export function alloc(size: usize): usize {\n    return __alloc(size);\n  }\n\n  /** Reallocates a chunk of memory to have at least the specified size. */\n  // @ts-ignore: decorator\n  @unsafe export function realloc(ptr: usize, size: usize): usize {\n    return __realloc(ptr, size);\n  }\n\n  /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n  // @ts-ignore: decorator\n  @unsafe export function free(ptr: usize): void {\n    __free(ptr);\n  }\n\n  /** Dangerously resets the entire heap. Specific to the stub runtime. */\n  // @ts-ignore: decorator\n  @unsafe export function reset(): void {\n    if (isDefined(__reset)) {\n      __reset();\n    } else {\n      throw new Error(E_NOTIMPLEMENTED);\n    }\n  }\n}\n","export function memcpy(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memcpy.c\n  var w: u32, x: u32;\n\n  // copy 1 byte each until src is aligned to 4 bytes\n  while (n && (src & 3)) {\n    store<u8>(dest++, load<u8>(src++));\n    n--;\n  }\n\n  // if dst is aligned to 4 bytes as well, copy 4 bytes each\n  if ((dest & 3) == 0) {\n    while (n >= 16) {\n      store<u32>(dest     , load<u32>(src     ));\n      store<u32>(dest +  4, load<u32>(src +  4));\n      store<u32>(dest +  8, load<u32>(src +  8));\n      store<u32>(dest + 12, load<u32>(src + 12));\n      src += 16; dest += 16; n -= 16;\n    }\n    if (n & 8) {\n      store<u32>(dest    , load<u32>(src    ));\n      store<u32>(dest + 4, load<u32>(src + 4));\n      dest += 8; src += 8;\n    }\n    if (n & 4) {\n      store<u32>(dest, load<u32>(src));\n      dest += 4; src += 4;\n    }\n    if (n & 2) { // drop to 2 bytes each\n      store<u16>(dest, load<u16>(src));\n      dest += 2; src += 2;\n    }\n    if (n & 1) { // drop to 1 byte\n      store<u8>(dest++, load<u8>(src++));\n    }\n    return;\n  }\n\n  // if dst is not aligned to 4 bytes, use alternating shifts to copy 4 bytes each\n  // doing shifts if faster when copying enough bytes (here: 32 or more)\n  if (n >= 32) {\n    switch (<u32>dest & 3) {\n      // known to be != 0\n      case 1: {\n        w = load<u32>(src);\n        store<u8>(dest++, load<u8>(src++));\n        store<u8>(dest++, load<u8>(src++));\n        store<u8>(dest++, load<u8>(src++));\n        n -= 3;\n        while (n >= 17) {\n          x = load<u32>(src + 1);\n          store<u32>(dest, w >> 24 | x << 8);\n          w = load<u32>(src + 5);\n          store<u32>(dest + 4, x >> 24 | w << 8);\n          x = load<u32>(src + 9);\n          store<u32>(dest + 8, w >> 24 | x << 8);\n          w = load<u32>(src + 13);\n          store<u32>(dest + 12, x >> 24 | w << 8);\n          src += 16; dest += 16; n -= 16;\n        }\n        break;\n      }\n      case 2: {\n        w = load<u32>(src);\n        store<u8>(dest++, load<u8>(src++));\n        store<u8>(dest++, load<u8>(src++));\n        n -= 2;\n        while (n >= 18) {\n          x = load<u32>(src + 2);\n          store<u32>(dest, w >> 16 | x << 16);\n          w = load<u32>(src + 6);\n          store<u32>(dest + 4, x >> 16 | w << 16);\n          x = load<u32>(src + 10);\n          store<u32>(dest + 8, w >> 16 | x << 16);\n          w = load<u32>(src + 14);\n          store<u32>(dest + 12, x >> 16 | w << 16);\n          src += 16; dest += 16; n -= 16;\n        }\n        break;\n      }\n      case 3: {\n        w = load<u32>(src);\n        store<u8>(dest++, load<u8>(src++));\n        n -= 1;\n        while (n >= 19) {\n          x = load<u32>(src + 3);\n          store<u32>(dest, w >> 8 | x << 24);\n          w = load<u32>(src + 7);\n          store<u32>(dest + 4, x >> 8 | w << 24);\n          x = load<u32>(src + 11);\n          store<u32>(dest + 8, w >> 8 | x << 24);\n          w = load<u32>(src + 15);\n          store<u32>(dest + 12, x >> 8 | w << 24);\n          src += 16; dest += 16; n -= 16;\n        }\n        break;\n      }\n    }\n  }\n\n  // copy remaining bytes one by one\n  if (n & 16) {\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n  }\n  if (n & 8) {\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n  }\n  if (n & 4) {\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n  }\n  if (n & 2) {\n    store<u8>(dest++, load<u8>(src++));\n    store<u8>(dest++, load<u8>(src++));\n  }\n  if (n & 1) {\n    store<u8>(dest++, load<u8>(src++));\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function memmove(dest: usize, src: usize, n: usize): void { // see: musl/src/string/memmove.c\n  if (dest === src) return;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (src - dest - n <= -(n << 1)) {\n      memcpy(dest, src, n);\n      return;\n    }\n  }\n  if (dest < src) {\n    if (ASC_SHRINK_LEVEL < 2) {\n      if ((src & 7) == (dest & 7)) {\n        while (dest & 7) {\n          if (!n) return;\n          --n;\n          store<u8>(dest++, load<u8>(src++));\n        }\n        while (n >= 8) {\n          store<u64>(dest, load<u64>(src));\n          n    -= 8;\n          dest += 8;\n          src  += 8;\n        }\n      }\n    }\n    while (n) {\n      store<u8>(dest++, load<u8>(src++));\n      --n;\n    }\n  } else {\n    if (ASC_SHRINK_LEVEL < 2) {\n      if ((src & 7) == (dest & 7)) {\n        while ((dest + n) & 7) {\n          if (!n) return;\n          store<u8>(dest + --n, load<u8>(src + n));\n        }\n        while (n >= 8) {\n          n -= 8;\n          store<u64>(dest + n, load<u64>(src + n));\n        }\n      }\n    }\n    while (n) {\n      store<u8>(dest + --n, load<u8>(src + n));\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function memset(dest: usize, c: u8, n: usize): void { // see: musl/src/string/memset\n  if (ASC_SHRINK_LEVEL > 1) {\n    while (n) {\n      store<u8>(dest++, c);\n      --n;\n    }\n  } else {\n    // fill head and tail with minimal branching\n    if (!n) return;\n    let dend = dest + n;\n    store<u8>(dest, c);\n    store<u8>(dend - 1, c);\n    if (n <= 2) return;\n    store<u8>(dest, c, 1);\n    store<u8>(dest, c, 2);\n    store<u8>(dend - 2, c);\n    store<u8>(dend - 3, c);\n    if (n <= 6) return;\n    store<u8>(dest, c, 3);\n    store<u8>(dend - 4, c);\n    if (n <= 8) return;\n\n    // advance pointer to align it at 4-byte boundary\n    let k: usize = -dest & 3;\n    dest += k;\n    n -= k;\n    n &= -4;\n\n    let c32: u32 = <u32>-1 / 255 * c;\n\n    // fill head/tail up to 28 bytes each in preparation\n    dend = dest + n;\n    store<u32>(dest, c32);\n    store<u32>(dend - 4, c32);\n    if (n <= 8) return;\n    store<u32>(dest, c32, 4);\n    store<u32>(dest, c32, 8);\n    store<u32>(dend - 12, c32);\n    store<u32>(dend - 8, c32);\n    if (n <= 24) return;\n    store<u32>(dest, c32, 12);\n    store<u32>(dest, c32, 16);\n    store<u32>(dest, c32, 20);\n    store<u32>(dest, c32, 24);\n    store<u32>(dend - 28, c32);\n    store<u32>(dend - 24, c32);\n    store<u32>(dend - 20, c32);\n    store<u32>(dend - 16, c32);\n\n    // align to a multiple of 8\n    k = 24 + (dest & 4);\n    dest += k;\n    n -= k;\n\n    // copy 32 bytes each\n    let c64: u64 = <u64>c32 | (<u64>c32 << 32);\n    while (n >= 32) {\n      store<u64>(dest, c64);\n      store<u64>(dest, c64, 8);\n      store<u64>(dest, c64, 16);\n      store<u64>(dest, c64, 24);\n      n -= 32;\n      dest += 32;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function memcmp(vl: usize, vr: usize, n: usize): i32 {\n  if (vl == vr) return 0;\n  if (ASC_SHRINK_LEVEL < 2) {\n    if ((vl & 7) == (vr & 7)) {\n      while (vl & 7) {\n        if (!n) return 0;\n        let a = <i32>load<u8>(vl);\n        let b = <i32>load<u8>(vr);\n        if (a != b) return a - b;\n        n--; vl++; vr++;\n      }\n      while (n >= 8) {\n        if (load<u64>(vl) != load<u64>(vr)) break;\n        vl += 8;\n        vr += 8;\n        n  -= 8;\n      }\n    }\n  }\n  while (n--) {\n    let a = <i32>load<u8>(vl);\n    let b = <i32>load<u8>(vr);\n    if (a != b) return a - b;\n    vl++; vr++;\n  }\n  return 0;\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data<u64>([\n  // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n  // used for computing 2^(k/N) for an int |k| < 150 N as\n  // double(tab[k%N] + (k << 52-BITS))\n  0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n  0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n  0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n  0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n  0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n  0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n  0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n  0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n  const\n    N      = 1 << EXP2F_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N, // 0x1.8p+52\n    Ox127f = reinterpret<f32>(0x7F000000);\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n  var xd = <f64>x;\n  var ix = reinterpret<u32>(x);\n  var ux = ix >> 20 & 0x7FF;\n  if (ux >= 0x430) {\n    // |x| >= 128 or x is nan.\n    if (ix == 0xFF800000) return 0; // x == -Inf    -> 0\n    if (ux >= 0x7F8) return x + x;  // x == Inf/NaN -> Inf/NaN\n    if (x > 0) return x * Ox127f;   // x >     0    -> HugeVal (Owerflow)\n    if (x <= -150) return 0;        // x <= -150    -> 0 (Underflow)\n  }\n\n  // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n  var kd = xd + shift;\n  var ki = reinterpret<u64>(kd);\n  var r  = xd - (kd - shift);\n  var t: u64, y: f64, s: f64;\n\n  // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += ki << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  y  = C2 * r + 1;\n  y += (C0 * r + C1) * (r  * r);\n  y *= s;\n\n  return <f32>y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n  const\n    N        = 1 << EXP2F_TABLE_BITS,\n    N_MASK   = N - 1,\n    shift    = reinterpret<f64>(0x4338000000000000),        // 0x1.8p+52\n    InvLn2N  = reinterpret<f64>(0x3FF71547652B82FE) * N,    // 0x1.71547652b82fep+0\n    Ox1p127f = reinterpret<f32>(0x7F000000);\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3) / N / N,     // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6) / N;         // 0x1.62e42ff0c52d6p-1\n\n  var xd = <f64>x;\n  var ix = reinterpret<u32>(x);\n  var ux = ix >> 20 & 0x7FF;\n  if (ux >= 0x42B) {\n    // |x| >= 88 or x is nan.\n    if (ix == 0xFF800000) return 0;                            // x == -Inf    -> 0\n    if (ux >= 0x7F8) return x + x;                             // x == Inf/NaN -> Inf/NaN\n    if (x > reinterpret<f32>(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128)  ~=  88.72 -> HugeVal (Owerflow)\n    if (x < reinterpret<f32>(0xC2CFF1B4)) return 0;            // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n  }\n\n  // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n  var z = InvLn2N * xd;\n\n  // Round and convert z to int, the result is in [-150*N, 128*N] and\n  // ideally ties-to-even rule is used, otherwise the magnitude of r\n  // can be bigger which gives larger approximation error.\n  var kd = <f64>(z + shift);\n  var ki = reinterpret<u64>(kd);\n  var r  = z - (kd - shift);\n  var s: f64, y: f64, t: u64;\n\n  // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += ki << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  z  = C0 * r + C1;\n  y  = C2 * r + 1;\n  y += z * (r * r);\n  y *= s;\n\n  return <f32>y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data<f64>([\n  reinterpret<f64>(0x3FF661EC79F8F3BE), reinterpret<f64>(0xBFDEFEC65B963019), // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n  reinterpret<f64>(0x3FF571ED4AAF883D), reinterpret<f64>(0xBFDB0B6832D4FCA4), // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n  reinterpret<f64>(0x3FF49539F0F010B0), reinterpret<f64>(0xBFD7418B0A1FB77B), // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n  reinterpret<f64>(0x3FF3C995B0B80385), reinterpret<f64>(0xBFD39DE91A6DCF7B), // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n  reinterpret<f64>(0x3FF30D190C8864A5), reinterpret<f64>(0xBFD01D9BF3F2B631), // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n  reinterpret<f64>(0x3FF25E227B0B8EA0), reinterpret<f64>(0xBFC97C1D1B3B7AF0), // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n  reinterpret<f64>(0x3FF1BB4A4A1A343F), reinterpret<f64>(0xBFC2F9E393AF3C9F), // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n  reinterpret<f64>(0x3FF12358F08AE5BA), reinterpret<f64>(0xBFB960CBBF788D5C), // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n  reinterpret<f64>(0x3FF0953F419900A7), reinterpret<f64>(0xBFAA6F9DB6475FCE), // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n  reinterpret<f64>(0x3FF0000000000000), 0,                                    // 0x1p+0,                0x0,\n  reinterpret<f64>(0x3FEE608CFD9A47AC), reinterpret<f64>(0x3FB338CA9F24F53D), // 0x1.e608cfd9a47acp-1,  0x1.338ca9f24f53dp-4,\n  reinterpret<f64>(0x3FECA4B31F026AA0), reinterpret<f64>(0x3FC476A9543891BA), // 0x1.ca4b31f026aap-1 ,  0x1.476a9543891bap-3,\n  reinterpret<f64>(0x3FEB2036576AFCE6), reinterpret<f64>(0x3FCE840B4AC4E4D2), // 0x1.b2036576afce6p-1,  0x1.e840b4ac4e4d2p-3,\n  reinterpret<f64>(0x3FE9C2D163A1AA2D), reinterpret<f64>(0x3FD40645F0C6651C), // 0x1.9c2d163a1aa2dp-1,  0x1.40645f0c6651cp-2,\n  reinterpret<f64>(0x3FE886E6037841ED), reinterpret<f64>(0x3FD88E9C2C1B9FF8), // 0x1.886e6037841edp-1,  0x1.88e9c2c1b9ff8p-2,\n  reinterpret<f64>(0x3FE767DCF5534862), reinterpret<f64>(0x3FDCE0A44EB17BCC)  // 0x1.767dcf5534862p-1,  0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n  const\n    N_MASK  = (1 << LOG2F_TABLE_BITS) - 1,\n    Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f\n\n  const\n    A0 = reinterpret<f64>(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n    A1 = reinterpret<f64>(0x3FDECABF496832E0), //  0x1.ecabf496832ep-2\n    A2 = reinterpret<f64>(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n    A3 = reinterpret<f64>(0x3FF715475F35C8B8); //  0x1.715475f35c8b8p0\n\n  var ux = reinterpret<u32>(x);\n  // Fix sign of zero with downward rounding when x==1.\n  // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n  if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n    // x < 0x1p-126 or inf or nan.\n    if (ux * 2 == 0) return -Infinity;\n    if (ux == 0x7F800000) return x; // log2(inf) == inf.\n    if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ux = reinterpret<u32>(x * Ox1p23f);\n    ux -= 23 << 23;\n  }\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp  = ux - 0x3F330000;\n  var i    = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n  var top  = tmp & 0xFF800000;\n  var iz   = ux - top;\n  var k    = <i32>tmp >> 23;\n\n  var invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  var logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n  var z    = <f64>reinterpret<f32>(iz);\n\n  // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n  var r  = z * invc - 1;\n  var y0 = logc + <f64>k;\n\n  // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n  var y  = A1 * r + A2;\n  var p  = A3 * r + y0;\n  var r2 = r * r;\n  y += A0 * r2;\n  y  = y * r2 + p;\n\n  return <f32>y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data<f64>([\n  reinterpret<f64>(0x3FF661EC79F8F3BE), reinterpret<f64>(0xBFD57BF7808CAADE), // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n  reinterpret<f64>(0x3FF571ED4AAF883D), reinterpret<f64>(0xBFD2BEF0A7C06DDB), // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n  reinterpret<f64>(0x3FF49539F0F010B0), reinterpret<f64>(0xBFD01EAE7F513A67), // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n  reinterpret<f64>(0x3FF3C995B0B80385), reinterpret<f64>(0xBFCB31D8A68224E9), // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n  reinterpret<f64>(0x3FF30D190C8864A5), reinterpret<f64>(0xBFC6574F0AC07758), // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n  reinterpret<f64>(0x3FF25E227B0B8EA0), reinterpret<f64>(0xBFC1AA2BC79C8100), // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3  ,\n  reinterpret<f64>(0x3FF1BB4A4A1A343F), reinterpret<f64>(0xBFBA4E76CE8C0E5E), // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n  reinterpret<f64>(0x3FF12358F08AE5BA), reinterpret<f64>(0xBFB1973C5A611CCC), // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n  reinterpret<f64>(0x3FF0953F419900A7), reinterpret<f64>(0xBFA252F438E10C1E), // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n  reinterpret<f64>(0x3FF0000000000000), 0,                                    // 0x1p+0,                0,\n  reinterpret<f64>(0x3FEE608CFD9A47AC), reinterpret<f64>(0x3FAAA5AA5DF25984), // 0x1.e608cfd9a47acp-1,  0x1.aa5aa5df25984p-5,\n  reinterpret<f64>(0x3FECA4B31F026AA0), reinterpret<f64>(0x3FBC5E53AA362EB4), // 0x1.ca4b31f026aap-1 ,  0x1.c5e53aa362eb4p-4,\n  reinterpret<f64>(0x3FEB2036576AFCE6), reinterpret<f64>(0x3FC526E57720DB08), // 0x1.b2036576afce6p-1,  0x1.526e57720db08p-3,\n  reinterpret<f64>(0x3FE9C2D163A1AA2D), reinterpret<f64>(0x3FCBC2860D224770), // 0x1.9c2d163a1aa2dp-1,  0x1.bc2860d22477p-3 ,\n  reinterpret<f64>(0x3FE886E6037841ED), reinterpret<f64>(0x3FD1058BC8A07EE1), // 0x1.886e6037841edp-1,  0x1.1058bc8a07ee1p-2,\n  reinterpret<f64>(0x3FE767DCF5534862), reinterpret<f64>(0x3FD4043057B6EE09)  // 0x1.767dcf5534862p-1,  0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n  const\n    N_MASK  = (1 << LOGF_TABLE_BITS) - 1,\n    Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f\n\n  const\n    Ln2 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n    A0  = reinterpret<f64>(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n    A1  = reinterpret<f64>(0x3FD5575B0BE00B6A), //  0x1.5575b0be00b6ap-2\n    A2  = reinterpret<f64>(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n  var ux = reinterpret<u32>(x);\n  // Fix sign of zero with downward rounding when x==1.\n  // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n  if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n    // x < 0x1p-126 or inf or nan.\n    if ((ux << 1) == 0) return -Infinity;\n    if (ux == 0x7F800000) return x; // log(inf) == inf.\n    if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ux = reinterpret<u32>(x * Ox1p23f);\n    ux -= 23 << 23;\n  }\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp = ux - 0x3F330000;\n  var i   = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n  var k   = <i32>tmp >> 23;\n  var iz  = ux - (tmp & 0x1FF << 23);\n\n  var invc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  var logc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n\n  var z = <f64>reinterpret<f32>(iz);\n\n  // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n  var r = z * invc - 1;\n  var y0 = logc + <f64>k * Ln2;\n\n  // Pipelined polynomial evaluation to approximate log1p(r).\n  var r2 = r * r;\n  var y  = A1 * r + A2;\n  y += A0 * r2;\n  y = y * r2 + (y0 + r);\n\n  return <f32>y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n  return (ux << 1) - 1 >= (<u32>0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n  var e = iy >> 23 & 0xFF;\n  if (e < 0x7F     ) return 0;\n  if (e > 0x7F + 23) return 2;\n  e = 1 << (0x7F + 23 - e);\n  if (iy & (e - 1)) return 0;\n  if (iy &  e     ) return 1;\n  return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n  const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n  const\n    A0 = reinterpret<f64>(0x3FD27616C9496E0B), //  0x1.27616c9496e0bp-2\n    A1 = reinterpret<f64>(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n    A2 = reinterpret<f64>(0x3FDEC70A6CA7BADD), //  0x1.ec70a6ca7baddp-2\n    A3 = reinterpret<f64>(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n    A4 = reinterpret<f64>(0x3FF71547652AB82B); //  0x1.71547652ab82bp+0\n\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp  = ux - 0x3F330000;\n  var i    = <usize>((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n  var top  = tmp & 0xFF800000;\n  var uz   = ux - top;\n  var k    = <i32>(<i32>top >> 23);\n\n  var invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  var logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n  var z    = <f64>reinterpret<f32>(uz);\n\n  // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n  var r  = z * invc - 1;\n  var y0 = logc + <f64>k;\n\n  // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n  var y = A0 * r + A1;\n  var p = A2 * r + A3;\n  var q = A4 * r + y0;\n\n  r *= r;\n  q += p * r;\n  y  = y * (r * r) + q;\n\n  return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not.  The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n  const\n    N      = 1 << EXP2F_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p+52\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n  // x = k/N + r with r in [-1/(2N), 1/(2N)]\n  var kd = <f64>(xd + shift);\n  var ki = reinterpret<u64>(kd);\n  var r  = xd - (kd - shift);\n  var t: u64, z: f64, y: f64, s: f64;\n\n  // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  z  = C0 * r + C1;\n  y  = C2 * r + 1;\n  y += z * (r * r);\n  y *= s;\n  return <f32>y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n  return select<f32>(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n  return xflowf(sign, reinterpret<f32>(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n  return xflowf(sign, reinterpret<f32>(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n  const\n    Ox1p23f     = reinterpret<f32>(0x4B000000), // 0x1p23f\n    UPPER_LIMIT = reinterpret<f64>(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n    LOWER_LIMIT = -150.0,\n    SIGN_BIAS   = 1 << (EXP2F_TABLE_BITS + 11);\n\n  var signBias: u32 = 0;\n  var ix = reinterpret<u32>(x);\n  var iy = reinterpret<u32>(y);\n  var ny = 0;\n\n  if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n    // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n    if (ny) {\n      if ((iy << 1) == 0) return 1.0;\n      if (ix == 0x3F800000) return NaN; // original: 1.0\n      if ((ix << 1) > (<u32>0x7F800000 << 1) || (iy << 1) > (<u32>0x7F800000 << 1)) return x + y;\n      if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n      if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n      return y * y;\n    }\n    if (zeroinfnanf(ix)) {\n      let x2 = x * x;\n      if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n      return iy >> 31 ? 1 / x2 : x2;\n    }\n    // x and y are non-zero finite.\n    if (ix >> 31) {\n      // Finite x < 0.\n      let yint = checkintf(iy);\n      if (yint == 0) return (x - x) / (x - x);\n      if (yint == 1) signBias = SIGN_BIAS;\n      ix &= 0x7FFFFFFF;\n    }\n    if (ix < 0x00800000) {\n      // Normalize subnormal x so exponent becomes negative.\n      ix = reinterpret<u32>(x * Ox1p23f);\n      ix &= 0x7FFFFFFF;\n      ix -= 23 << 23;\n    }\n  }\n  var logx = log2f_inline(ix);\n  var ylogx = y * logx; // cannot overflow, y is single prec.\n  if ((reinterpret<u64>(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret<u64>(126.0) >> 47\n    // |y * log(x)| >= 126\n    if (ylogx  > UPPER_LIMIT) return oflowf(signBias); // overflow\n    if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n  }\n  return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data<u64>([\n  0x0000000000000000, 0x3FF0000000000000,\n  0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n  0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n  0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n  0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n  0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n  0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n  0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n  0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n  0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n  0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n  0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n  0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n  0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n  0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n  0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n  0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n  0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n  0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n  0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n  0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n  0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n  0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n  0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n  0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n  0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n  0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n  0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n  0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n  0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n  0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n  0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n  0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n  0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n  0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n  0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n  0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n  0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n  0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n  0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n  0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n  0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n  0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n  0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n  0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n  0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n  0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n  0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n  0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n  0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n  0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n  0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n  0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n  0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n  0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n  0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n  0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n  0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n  0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n  0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n  0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n  0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n  0xBC93CEDD78565858, 0x3FEEA23882552225,\n  0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n  0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n  0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n  0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n  0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n  0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n  0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n  0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n  0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n  0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n  0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n  0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n  0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n  0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n  0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n  0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n  0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n  0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n  0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n  0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n  0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n  0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n  0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n  0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n  0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n  0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n  0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n  0xBC87C50422622263, 0x3FEECC667B5DE565,\n  0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n  0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n  0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n  0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n  0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n  0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n  0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n  0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n  0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n  0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n  0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n  0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n  0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n  0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n  0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n  0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n  0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n  0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n  0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n  0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n  0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n  0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n  0xBC82919E2040220F, 0x3FEF60E316C98398,\n  0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n  0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n  0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n  0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n  0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n  0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n  0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n  0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n  0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n  0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n  0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n  0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n  0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n  0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double.  (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n  const\n    Ox1p_1022 = reinterpret<f64>(0x0010000000000000), // 0x1p-1022\n    Ox1p1009  = reinterpret<f64>(0x7F00000000000000); // 0x1p1009\n\n  var scale: f64;\n  if (!(ki & 0x80000000)) {\n    // k > 0, the exponent of scale might have overflowed by <= 460.\n    sbits -= u64(1009) << 52;\n    scale = reinterpret<f64>(sbits);\n    return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n  }\n  // k < 0, need special care in the subnormal range.\n  sbits += u64(1022) << 52;\n  // Note: sbits is signed scale.\n  scale = reinterpret<f64>(sbits);\n  var y = scale + scale * tmp;\n  if (abs(y) < 1.0) {\n    // Round y to the right precision before scaling it into the subnormal\n    // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n    // E is the worst-case ulp error outside the subnormal range.  So this\n    // is only useful if the goal is better than 1 ulp worst-case error.\n    let one = copysign(1.0, y);\n    let lo = scale - y + scale * tmp;\n    let hi = one + y;\n    lo = one - hi + y + lo;\n    y  = (hi + lo) - one;\n    // Fix the sign of 0.\n    if (y == 0.0) y = reinterpret<f64>(sbits & 0x8000000000000000);\n  }\n  return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n  const\n    N      = 1 << EXP_TABLE_BITS,\n    N_MASK = N - 1;\n\n  const\n    InvLn2N   = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n    NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000),     // -0x1.62e42fefa0000p-8\n    NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A),     // -0x1.cf79abc9e3b3ap-47\n    shift     = reinterpret<f64>(0x4338000000000000);     // 0x1.8p52;\n\n  const\n    C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n    C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n    C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n    C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n  var ux = reinterpret<u64>(x);\n  var abstop = <u32>(ux >> 52 & 0x7FF);\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) return 1;\n    if (abstop >= 0x409) {\n      if (ux == 0xFFF0000000000000) return 0;\n      if (abstop >= 0x7FF) return 1.0 + x;\n      return select<f64>(0, Infinity, ux >> 63);\n    }\n    // Large x is special cased below.\n    abstop = 0;\n  }\n\n  // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n  // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n  var z = InvLn2N * x;\n  // #if TOINT_INTRINSICS\n  // \tkd = roundtoint(z);\n  // \tki = converttoint(z);\n  // #elif EXP_USE_TOINT_NARROW\n  // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n  // var kd = z + shift;\n  // var ki = reinterpret<u64>(kd) >> 16;\n  // var kd = <f64><i32>ki;\n  // #else\n  // z - kd is in [-1, 1] in non-nearest rounding modes.\n  var kd = z + shift;\n  var ki = reinterpret<u64>(kd);\n  kd -= shift;\n  // #endif\n  var r = x + kd * NegLn2hiN + kd * NegLn2loN;\n  // 2^(k/N) ~= scale * (1 + tail).\n  var idx = <usize>((ki & N_MASK) << 1);\n  var top = ki << (52 - EXP_TABLE_BITS);\n\n  var tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()))); // T[idx]\n  // This is only a valid scale when -1023*N < k < 1024*N\n  var sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]\n  // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  var r2 = r * r;\n  // Without fma the worst case error is 0.25/N ulp larger.\n  // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n  var tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase(tmp, sbits, ki);\n  var scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n  // is no spurious underflow here even without fma.\n  return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding.  The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double.  (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n  const Ox1p_1022 = reinterpret<f64>(0x10000000000000); // 0x1p-1022\n  var scale: f64;\n  if ((ki & 0x80000000) == 0) {\n    // k > 0, the exponent of scale might have overflowed by 1\n    sbits -= u64(1) << 52;\n    scale = reinterpret<f64>(sbits);\n    return 2 * (scale * tmp + scale);\n  }\n  // k < 0, need special care in the subnormal range\n  sbits += u64(1022) << 52;\n  scale = reinterpret<f64>(sbits);\n  var y = scale * tmp + scale;\n  if (y < 1.0) {\n    // Round y to the right precision before scaling it into the subnormal\n    // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n    // E is the worst-case ulp error outside the subnormal range. So this\n    // is only useful if the goal is better than 1 ulp worst-case error.\n    let hi: f64, lo: f64;\n    lo = scale - y + scale * tmp;\n    hi = 1.0 + y;\n    lo = 1.0 - hi + y + lo;\n    y = (hi + lo) - 1.0;\n  }\n  return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n  const\n    N      = 1 << EXP_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p52\n\n  const\n    C1 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n    C2 = reinterpret<f64>(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n    C3 = reinterpret<f64>(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n    C4 = reinterpret<f64>(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n    C5 = reinterpret<f64>(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n  var ux = reinterpret<u64>(x);\n  var abstop = <u32>(ux >> 52 & 0x7ff);\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n    if (abstop >= 0x409) {\n      if (ux == 0xFFF0000000000000) return 0;\n      if (abstop >= 0x7FF) return 1.0 + x;\n      if (!(ux >> 63)) return Infinity;\n      else if (ux >= 0xC090CC0000000000) return 0;\n    }\n    if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n  }\n\n  // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n  // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n  var kd = x + shift;\n  var ki = reinterpret<u64>(kd);\n  kd -= shift; // k/N for int k\n  var r = x - kd;\n  // 2^(k/N) ~= scale * (1 + tail)\n  var idx = <usize>((ki & N_MASK) << 1);\n  var top = ki << (52 - EXP_TABLE_BITS);\n\n  var tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 0 << alignof<u64>())); // T[idx])\n  // This is only a valid scale when -1023*N < k < 1024*N\n  var sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]\n  // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution\n  var r2 = r * r;\n  // Without fma the worst case error is 0.5/N ulp larger.\n  // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n  var tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase2(tmp, sbits, ki);\n  var scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n  // is no spurious underflow here even without fma.\n  return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n  x = 2^k z\n  log2(x) = k + log2(c) + log2(z/c)\n  log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = (double)log2(c)\n  tab2[i].chi = (double)c\n  tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n  1) the rounding error in 0x1.8p10 + logc is 0,\n  2) the rounding error in z - chi - clo is < 0x1p-64 and\n  3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data<f64>([\n  //            invc                  ,                logc\n  reinterpret<f64>(0x3FF724286BB1ACF8), reinterpret<f64>(0xBFE1095FEECDB000),\n  reinterpret<f64>(0x3FF6E1F766D2CCA1), reinterpret<f64>(0xBFE08494BD76D000),\n  reinterpret<f64>(0x3FF6A13D0E30D48A), reinterpret<f64>(0xBFE00143AEE8F800),\n  reinterpret<f64>(0x3FF661EC32D06C85), reinterpret<f64>(0xBFDEFEC5360B4000),\n  reinterpret<f64>(0x3FF623FA951198F8), reinterpret<f64>(0xBFDDFDD91AB7E000),\n  reinterpret<f64>(0x3FF5E75BA4CF026C), reinterpret<f64>(0xBFDCFFAE0CC79000),\n  reinterpret<f64>(0x3FF5AC055A214FB8), reinterpret<f64>(0xBFDC043811FDA000),\n  reinterpret<f64>(0x3FF571ED0F166E1E), reinterpret<f64>(0xBFDB0B67323AE000),\n  reinterpret<f64>(0x3FF53909590BF835), reinterpret<f64>(0xBFDA152F5A2DB000),\n  reinterpret<f64>(0x3FF5014FED61ADDD), reinterpret<f64>(0xBFD9217F5AF86000),\n  reinterpret<f64>(0x3FF4CAB88E487BD0), reinterpret<f64>(0xBFD8304DB0719000),\n  reinterpret<f64>(0x3FF49539B4334FEE), reinterpret<f64>(0xBFD74189F9A9E000),\n  reinterpret<f64>(0x3FF460CBDFAFD569), reinterpret<f64>(0xBFD6552BB5199000),\n  reinterpret<f64>(0x3FF42D664EE4B953), reinterpret<f64>(0xBFD56B23A29B1000),\n  reinterpret<f64>(0x3FF3FB01111DD8A6), reinterpret<f64>(0xBFD483650F5FA000),\n  reinterpret<f64>(0x3FF3C995B70C5836), reinterpret<f64>(0xBFD39DE937F6A000),\n  reinterpret<f64>(0x3FF3991C4AB6FD4A), reinterpret<f64>(0xBFD2BAA1538D6000),\n  reinterpret<f64>(0x3FF3698E0CE099B5), reinterpret<f64>(0xBFD1D98340CA4000),\n  reinterpret<f64>(0x3FF33AE48213E7B2), reinterpret<f64>(0xBFD0FA853A40E000),\n  reinterpret<f64>(0x3FF30D191985BDB1), reinterpret<f64>(0xBFD01D9C32E73000),\n  reinterpret<f64>(0x3FF2E025CAB271D7), reinterpret<f64>(0xBFCE857DA2FA6000),\n  reinterpret<f64>(0x3FF2B404CF13CD82), reinterpret<f64>(0xBFCCD3C8633D8000),\n  reinterpret<f64>(0x3FF288B02C7CCB50), reinterpret<f64>(0xBFCB26034C14A000),\n  reinterpret<f64>(0x3FF25E2263944DE5), reinterpret<f64>(0xBFC97C1C2F4FE000),\n  reinterpret<f64>(0x3FF234563D8615B1), reinterpret<f64>(0xBFC7D6023F800000),\n  reinterpret<f64>(0x3FF20B46E33EAF38), reinterpret<f64>(0xBFC633A71A05E000),\n  reinterpret<f64>(0x3FF1E2EEFDCDA3DD), reinterpret<f64>(0xBFC494F5E9570000),\n  reinterpret<f64>(0x3FF1BB4A580B3930), reinterpret<f64>(0xBFC2F9E424E0A000),\n  reinterpret<f64>(0x3FF19453847F2200), reinterpret<f64>(0xBFC162595AFDC000),\n  reinterpret<f64>(0x3FF16E06C0D5D73C), reinterpret<f64>(0xBFBF9C9A75BD8000),\n  reinterpret<f64>(0x3FF1485F47B7E4C2), reinterpret<f64>(0xBFBC7B575BF9C000),\n  reinterpret<f64>(0x3FF12358AD0085D1), reinterpret<f64>(0xBFB960C60FF48000),\n  reinterpret<f64>(0x3FF0FEF00F532227), reinterpret<f64>(0xBFB64CE247B60000),\n  reinterpret<f64>(0x3FF0DB2077D03A8F), reinterpret<f64>(0xBFB33F78B2014000),\n  reinterpret<f64>(0x3FF0B7E6D65980D9), reinterpret<f64>(0xBFB0387D1A42C000),\n  reinterpret<f64>(0x3FF0953EFE7B408D), reinterpret<f64>(0xBFAA6F9208B50000),\n  reinterpret<f64>(0x3FF07325CAC53B83), reinterpret<f64>(0xBFA47A954F770000),\n  reinterpret<f64>(0x3FF05197E40D1B5C), reinterpret<f64>(0xBF9D23A8C50C0000),\n  reinterpret<f64>(0x3FF03091C1208EA2), reinterpret<f64>(0xBF916A2629780000),\n  reinterpret<f64>(0x3FF0101025B37E21), reinterpret<f64>(0xBF7720F8D8E80000),\n  reinterpret<f64>(0x3FEFC07EF9CAA76B), reinterpret<f64>(0x3F86FE53B1500000),\n  reinterpret<f64>(0x3FEF4465D3F6F184), reinterpret<f64>(0x3FA11CCCE10F8000),\n  reinterpret<f64>(0x3FEECC079F84107F), reinterpret<f64>(0x3FAC4DFC8C8B8000),\n  reinterpret<f64>(0x3FEE573A99975AE8), reinterpret<f64>(0x3FB3AA321E574000),\n  reinterpret<f64>(0x3FEDE5D6F0BD3DE6), reinterpret<f64>(0x3FB918A0D08B8000),\n  reinterpret<f64>(0x3FED77B681FF38B3), reinterpret<f64>(0x3FBE72E9DA044000),\n  reinterpret<f64>(0x3FED0CB5724DE943), reinterpret<f64>(0x3FC1DCD2507F6000),\n  reinterpret<f64>(0x3FECA4B2DC0E7563), reinterpret<f64>(0x3FC476AB03DEA000),\n  reinterpret<f64>(0x3FEC3F8EE8D6CB51), reinterpret<f64>(0x3FC7074377E22000),\n  reinterpret<f64>(0x3FEBDD2B4F020C4C), reinterpret<f64>(0x3FC98EDE8BA94000),\n  reinterpret<f64>(0x3FEB7D6C006015CA), reinterpret<f64>(0x3FCC0DB86AD2E000),\n  reinterpret<f64>(0x3FEB20366E2E338F), reinterpret<f64>(0x3FCE840AAFCEE000),\n  reinterpret<f64>(0x3FEAC57026295039), reinterpret<f64>(0x3FD0790AB4678000),\n  reinterpret<f64>(0x3FEA6D01BC2731DD), reinterpret<f64>(0x3FD1AC056801C000),\n  reinterpret<f64>(0x3FEA16D3BC3FF18B), reinterpret<f64>(0x3FD2DB11D4FEE000),\n  reinterpret<f64>(0x3FE9C2D14967FEAD), reinterpret<f64>(0x3FD406464EC58000),\n  reinterpret<f64>(0x3FE970E4F47C9902), reinterpret<f64>(0x3FD52DBE093AF000),\n  reinterpret<f64>(0x3FE920FB3982BCF2), reinterpret<f64>(0x3FD651902050D000),\n  reinterpret<f64>(0x3FE8D30187F759F1), reinterpret<f64>(0x3FD771D2CDEAF000),\n  reinterpret<f64>(0x3FE886E5EBB9F66D), reinterpret<f64>(0x3FD88E9C857D9000),\n  reinterpret<f64>(0x3FE83C97B658B994), reinterpret<f64>(0x3FD9A80155E16000),\n  reinterpret<f64>(0x3FE7F405FFC61022), reinterpret<f64>(0x3FDABE186ED3D000),\n  reinterpret<f64>(0x3FE7AD22181415CA), reinterpret<f64>(0x3FDBD0F2AEA0E000),\n  reinterpret<f64>(0x3FE767DCF99EFF8C), reinterpret<f64>(0x3FDCE0A43DBF4000)\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data<f64>([\n  //              chi                 ,                 clo\n  reinterpret<f64>(0x3FE6200012B90A8E), reinterpret<f64>(0x3C8904AB0644B605),\n  reinterpret<f64>(0x3FE66000045734A6), reinterpret<f64>(0x3C61FF9BEA62F7A9),\n  reinterpret<f64>(0x3FE69FFFC325F2C5), reinterpret<f64>(0x3C827ECFCB3C90BA),\n  reinterpret<f64>(0x3FE6E00038B95A04), reinterpret<f64>(0x3C88FF8856739326),\n  reinterpret<f64>(0x3FE71FFFE09994E3), reinterpret<f64>(0x3C8AFD40275F82B1),\n  reinterpret<f64>(0x3FE7600015590E10), reinterpret<f64>(0xBC72FD75B4238341),\n  reinterpret<f64>(0x3FE7A00012655BD5), reinterpret<f64>(0x3C7808E67C242B76),\n  reinterpret<f64>(0x3FE7E0003259E9A6), reinterpret<f64>(0xBC6208E426F622B7),\n  reinterpret<f64>(0x3FE81FFFEDB4B2D2), reinterpret<f64>(0xBC8402461EA5C92F),\n  reinterpret<f64>(0x3FE860002DFAFCC3), reinterpret<f64>(0x3C6DF7F4A2F29A1F),\n  reinterpret<f64>(0x3FE89FFFF78C6B50), reinterpret<f64>(0xBC8E0453094995FD),\n  reinterpret<f64>(0x3FE8E00039671566), reinterpret<f64>(0xBC8A04F3BEC77B45),\n  reinterpret<f64>(0x3FE91FFFE2BF1745), reinterpret<f64>(0xBC77FA34400E203C),\n  reinterpret<f64>(0x3FE95FFFCC5C9FD1), reinterpret<f64>(0xBC76FF8005A0695D),\n  reinterpret<f64>(0x3FE9A0003BBA4767), reinterpret<f64>(0x3C70F8C4C4EC7E03),\n  reinterpret<f64>(0x3FE9DFFFE7B92DA5), reinterpret<f64>(0x3C8E7FD9478C4602),\n  reinterpret<f64>(0x3FEA1FFFD72EFDAF), reinterpret<f64>(0xBC6A0C554DCDAE7E),\n  reinterpret<f64>(0x3FEA5FFFDE04FF95), reinterpret<f64>(0x3C867DA98CE9B26B),\n  reinterpret<f64>(0x3FEA9FFFCA5E8D2B), reinterpret<f64>(0xBC8284C9B54C13DE),\n  reinterpret<f64>(0x3FEADFFFDDAD03EA), reinterpret<f64>(0x3C5812C8EA602E3C),\n  reinterpret<f64>(0x3FEB1FFFF10D3D4D), reinterpret<f64>(0xBC8EFADDAD27789C),\n  reinterpret<f64>(0x3FEB5FFFCE21165A), reinterpret<f64>(0x3C53CB1719C61237),\n  reinterpret<f64>(0x3FEB9FFFD950E674), reinterpret<f64>(0x3C73F7D94194CE00),\n  reinterpret<f64>(0x3FEBE000139CA8AF), reinterpret<f64>(0x3C750AC4215D9BC0),\n  reinterpret<f64>(0x3FEC20005B46DF99), reinterpret<f64>(0x3C6BEEA653E9C1C9),\n  reinterpret<f64>(0x3FEC600040B9F7AE), reinterpret<f64>(0xBC7C079F274A70D6),\n  reinterpret<f64>(0x3FECA0006255FD8A), reinterpret<f64>(0xBC7A0B4076E84C1F),\n  reinterpret<f64>(0x3FECDFFFD94C095D), reinterpret<f64>(0x3C88F933F99AB5D7),\n  reinterpret<f64>(0x3FED1FFFF975D6CF), reinterpret<f64>(0xBC582C08665FE1BE),\n  reinterpret<f64>(0x3FED5FFFA2561C93), reinterpret<f64>(0xBC7B04289BD295F3),\n  reinterpret<f64>(0x3FED9FFF9D228B0C), reinterpret<f64>(0x3C870251340FA236),\n  reinterpret<f64>(0x3FEDE00065BC7E16), reinterpret<f64>(0xBC75011E16A4D80C),\n  reinterpret<f64>(0x3FEE200002F64791), reinterpret<f64>(0x3C89802F09EF62E0),\n  reinterpret<f64>(0x3FEE600057D7A6D8), reinterpret<f64>(0xBC7E0B75580CF7FA),\n  reinterpret<f64>(0x3FEEA00027EDC00C), reinterpret<f64>(0xBC8C848309459811),\n  reinterpret<f64>(0x3FEEE0006CF5CB7C), reinterpret<f64>(0xBC8F8027951576F4),\n  reinterpret<f64>(0x3FEF2000782B7DCC), reinterpret<f64>(0xBC8F81D97274538F),\n  reinterpret<f64>(0x3FEF6000260C450A), reinterpret<f64>(0xBC4071002727FFDC),\n  reinterpret<f64>(0x3FEF9FFFE88CD533), reinterpret<f64>(0xBC581BDCE1FDA8B0),\n  reinterpret<f64>(0x3FEFDFFFD50F8689), reinterpret<f64>(0x3C87F91ACB918E6E),\n  reinterpret<f64>(0x3FF0200004292367), reinterpret<f64>(0x3C9B7FF365324681),\n  reinterpret<f64>(0x3FF05FFFE3E3D668), reinterpret<f64>(0x3C86FA08DDAE957B),\n  reinterpret<f64>(0x3FF0A0000A85A757), reinterpret<f64>(0xBC57E2DE80D3FB91),\n  reinterpret<f64>(0x3FF0E0001A5F3FCC), reinterpret<f64>(0xBC91823305C5F014),\n  reinterpret<f64>(0x3FF11FFFF8AFBAF5), reinterpret<f64>(0xBC8BFABB6680BAC2),\n  reinterpret<f64>(0x3FF15FFFE54D91AD), reinterpret<f64>(0xBC9D7F121737E7EF),\n  reinterpret<f64>(0x3FF1A00011AC36E1), reinterpret<f64>(0x3C9C000A0516F5FF),\n  reinterpret<f64>(0x3FF1E00019C84248), reinterpret<f64>(0xBC9082FBE4DA5DA0),\n  reinterpret<f64>(0x3FF220000FFE5E6E), reinterpret<f64>(0xBC88FDD04C9CFB43),\n  reinterpret<f64>(0x3FF26000269FD891), reinterpret<f64>(0x3C8CFE2A7994D182),\n  reinterpret<f64>(0x3FF2A00029A6E6DA), reinterpret<f64>(0xBC700273715E8BC5),\n  reinterpret<f64>(0x3FF2DFFFE0293E39), reinterpret<f64>(0x3C9B7C39DAB2A6F9),\n  reinterpret<f64>(0x3FF31FFFF7DCF082), reinterpret<f64>(0x3C7DF1336EDC5254),\n  reinterpret<f64>(0x3FF35FFFF05A8B60), reinterpret<f64>(0xBC9E03564CCD31EB),\n  reinterpret<f64>(0x3FF3A0002E0EAECC), reinterpret<f64>(0x3C75F0E74BD3A477),\n  reinterpret<f64>(0x3FF3E000043BB236), reinterpret<f64>(0x3C9C7DCB149D8833),\n  reinterpret<f64>(0x3FF4200002D187FF), reinterpret<f64>(0x3C7E08AFCF2D3D28),\n  reinterpret<f64>(0x3FF460000D387CB1), reinterpret<f64>(0x3C820837856599A6),\n  reinterpret<f64>(0x3FF4A00004569F89), reinterpret<f64>(0xBC89FA5C904FBCD2),\n  reinterpret<f64>(0x3FF4E000043543F3), reinterpret<f64>(0xBC781125ED175329),\n  reinterpret<f64>(0x3FF51FFFCC027F0F), reinterpret<f64>(0x3C9883D8847754DC),\n  reinterpret<f64>(0x3FF55FFFFD87B36F), reinterpret<f64>(0xBC8709E731D02807),\n  reinterpret<f64>(0x3FF59FFFF21DF7BA), reinterpret<f64>(0x3C87F79F68727B02),\n  reinterpret<f64>(0x3FF5DFFFEBFC3481), reinterpret<f64>(0xBC9180902E30E93E)\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n  const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n  const\n    LO: u64 = 0x3FEEA4AF00000000, // reinterpret<u64>(1.0 - 0x1.5b51p-5)\n    HI: u64 = 0x3FF0B55900000000; // reinterpret<u64>(1.0 + 0x1.6ab2p-5)\n\n  const\n    InvLn2hi = reinterpret<f64>(0x3FF7154765200000), // 0x1.7154765200000p+0\n    InvLn2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n    Ox1p52   = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  const\n    B0 = reinterpret<f64>(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n    B1 = reinterpret<f64>(0x3FDEC709DC3A03F7), //  0x1.ec709dc3a03f7p-2\n    B2 = reinterpret<f64>(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n    B3 = reinterpret<f64>(0x3FD2776C50F05BE4), //  0x1.2776c50f05be4p-2\n    B4 = reinterpret<f64>(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n    B5 = reinterpret<f64>(0x3FCA61761EC4E736), //  0x1.a61761ec4e736p-3\n    B6 = reinterpret<f64>(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n    B7 = reinterpret<f64>(0x3FC484D154F01B4A), //  0x1.484d154f01b4ap-3\n    B8 = reinterpret<f64>(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n    B9 = reinterpret<f64>(0x3FC0B32F285AEE66); //  0x1.0b32f285aee66p-3\n\n  const\n    A0 = reinterpret<f64>(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n    A1 = reinterpret<f64>(0x3FDEC709DC3A04BE), //  0x1.ec709dc3a04bep-2\n    A2 = reinterpret<f64>(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n    A3 = reinterpret<f64>(0x3FD2776C50034C48), //  0x1.2776c50034c48p-2\n    A4 = reinterpret<f64>(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n    A5 = reinterpret<f64>(0x3FCA6225E117F92E); //  0x1.a6225e117f92ep-3\n\n  var ix = reinterpret<u64>(x);\n  if (ix - LO < HI - LO) {\n    let r = x - 1.0;\n    // #if __FP_FAST_FMA\n    //     hi = r * InvLn2hi;\n    //     lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n    // #else\n    let rhi = reinterpret<f64>(reinterpret<u64>(r) & 0xFFFFFFFF00000000);\n    let rlo = r - rhi;\n    let hi  = rhi * InvLn2hi;\n    let lo  = rlo * InvLn2hi + r * InvLn2lo;\n    // #endif\n    let r2 = r * r; // rounding error: 0x1p-62\n    let r4 = r2 * r2;\n    // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n    let p = r2 * (B0 + r * B1);\n    let y = hi + p;\n    lo += hi - y + p;\n    lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n          r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n    return y + lo;\n  }\n  var top = <u32>(ix >> 48);\n  if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n    // x < 0x1p-1022 or inf or nan.\n    if ((ix << 1) == 0) return -1.0 / (x * x);\n    if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n    if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ix = reinterpret<u64>(x * Ox1p52);\n    ix -= u64(52) << 52;\n  }\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp  = ix - 0x3FE6000000000000;\n  var i    = <usize>((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n  var k    = <i64>tmp >> 52;\n  var iz   = ix - (tmp & 0xFFF0000000000000);\n\n  var invc = load<f64>(LOG2_DATA_TAB1  + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].invc;\n  var logc = load<f64>(LOG2_DATA_TAB1  + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].logc;\n  var z    = reinterpret<f64>(iz);\n  var kd   = <f64>k;\n\n  // log2(x) = log2(z/c) + log2(c) + k.\n  // r ~= z/c - 1, |r| < 1/(2*N).\n  // #if __FP_FAST_FMA\n  // \t// rounding error: 0x1p-55/N.\n  // \tr = __builtin_fma(z, invc, -1.0);\n  // \tt1 = r * InvLn2hi;\n  // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n  // #else\n  // rounding error: 0x1p-55/N + 0x1p-65.\n  var chi = load<f64>(LOG2_DATA_TAB2 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].chi;\n  var clo = load<f64>(LOG2_DATA_TAB2 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].clo;\n\n  var r   = (z - chi - clo) * invc;\n  var rhi = reinterpret<f64>(reinterpret<u64>(r) & 0xFFFFFFFF00000000);\n  var rlo = r - rhi;\n  var t1  = rhi * InvLn2hi;\n  var t2  = rlo * InvLn2hi + r * InvLn2lo;\n  // #endif\n\n  // hi + lo = r/ln2 + log2(c) + k\n  var t3 = kd + logc;\n  var hi = t3 + t1;\n  var lo = t3 - hi + t1 + t2;\n\n  // log2(r+1) = r/ln2 + r^2*poly(r)\n  // Evaluation is optimized assuming superscalar pipelined execution\n  var r2 = r * r; // rounding error: 0x1p-54/N^2\n  // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n  // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n  var p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n  return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n  x = 2^k z\n  log(x) = k ln2 + log(c) + log(z/c)\n  log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = (double)log(c)\n  tab2[i].chi = (double)c\n  tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n  1) the rounding error in 0x1.8p9 + logc is 0,\n  2) the rounding error in z - chi - clo is < 0x1p-66 and\n  3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data<f64>([\n  //              invc                ,                 logc\n  reinterpret<f64>(0x3FF734F0C3E0DE9F), reinterpret<f64>(0xBFD7CC7F79E69000),\n  reinterpret<f64>(0x3FF713786A2CE91F), reinterpret<f64>(0xBFD76FEEC20D0000),\n  reinterpret<f64>(0x3FF6F26008FAB5A0), reinterpret<f64>(0xBFD713E31351E000),\n  reinterpret<f64>(0x3FF6D1A61F138C7D), reinterpret<f64>(0xBFD6B85B38287800),\n  reinterpret<f64>(0x3FF6B1490BC5B4D1), reinterpret<f64>(0xBFD65D5590807800),\n  reinterpret<f64>(0x3FF69147332F0CBA), reinterpret<f64>(0xBFD602D076180000),\n  reinterpret<f64>(0x3FF6719F18224223), reinterpret<f64>(0xBFD5A8CA86909000),\n  reinterpret<f64>(0x3FF6524F99A51ED9), reinterpret<f64>(0xBFD54F4356035000),\n  reinterpret<f64>(0x3FF63356AA8F24C4), reinterpret<f64>(0xBFD4F637C36B4000),\n  reinterpret<f64>(0x3FF614B36B9DDC14), reinterpret<f64>(0xBFD49DA7FDA85000),\n  reinterpret<f64>(0x3FF5F66452C65C4C), reinterpret<f64>(0xBFD445923989A800),\n  reinterpret<f64>(0x3FF5D867B5912C4F), reinterpret<f64>(0xBFD3EDF439B0B800),\n  reinterpret<f64>(0x3FF5BABCCB5B90DE), reinterpret<f64>(0xBFD396CE448F7000),\n  reinterpret<f64>(0x3FF59D61F2D91A78), reinterpret<f64>(0xBFD3401E17BDA000),\n  reinterpret<f64>(0x3FF5805612465687), reinterpret<f64>(0xBFD2E9E2EF468000),\n  reinterpret<f64>(0x3FF56397CEE76BD3), reinterpret<f64>(0xBFD2941B3830E000),\n  reinterpret<f64>(0x3FF54725E2A77F93), reinterpret<f64>(0xBFD23EC58CDA8800),\n  reinterpret<f64>(0x3FF52AFF42064583), reinterpret<f64>(0xBFD1E9E129279000),\n  reinterpret<f64>(0x3FF50F22DBB2BDDF), reinterpret<f64>(0xBFD1956D2B48F800),\n  reinterpret<f64>(0x3FF4F38F4734DED7), reinterpret<f64>(0xBFD141679AB9F800),\n  reinterpret<f64>(0x3FF4D843CFDE2840), reinterpret<f64>(0xBFD0EDD094EF9800),\n  reinterpret<f64>(0x3FF4BD3EC078A3C8), reinterpret<f64>(0xBFD09AA518DB1000),\n  reinterpret<f64>(0x3FF4A27FC3E0258A), reinterpret<f64>(0xBFD047E65263B800),\n  reinterpret<f64>(0x3FF4880524D48434), reinterpret<f64>(0xBFCFEB224586F000),\n  reinterpret<f64>(0x3FF46DCE1B192D0B), reinterpret<f64>(0xBFCF474A7517B000),\n  reinterpret<f64>(0x3FF453D9D3391854), reinterpret<f64>(0xBFCEA4443D103000),\n  reinterpret<f64>(0x3FF43A2744B4845A), reinterpret<f64>(0xBFCE020D44E9B000),\n  reinterpret<f64>(0x3FF420B54115F8FB), reinterpret<f64>(0xBFCD60A22977F000),\n  reinterpret<f64>(0x3FF40782DA3EF4B1), reinterpret<f64>(0xBFCCC00104959000),\n  reinterpret<f64>(0x3FF3EE8F5D57FE8F), reinterpret<f64>(0xBFCC202956891000),\n  reinterpret<f64>(0x3FF3D5D9A00B4CE9), reinterpret<f64>(0xBFCB81178D811000),\n  reinterpret<f64>(0x3FF3BD60C010C12B), reinterpret<f64>(0xBFCAE2C9CCD3D000),\n  reinterpret<f64>(0x3FF3A5242B75DAB8), reinterpret<f64>(0xBFCA45402E129000),\n  reinterpret<f64>(0x3FF38D22CD9FD002), reinterpret<f64>(0xBFC9A877681DF000),\n  reinterpret<f64>(0x3FF3755BC5847A1C), reinterpret<f64>(0xBFC90C6D69483000),\n  reinterpret<f64>(0x3FF35DCE49AD36E2), reinterpret<f64>(0xBFC87120A645C000),\n  reinterpret<f64>(0x3FF34679984DD440), reinterpret<f64>(0xBFC7D68FB4143000),\n  reinterpret<f64>(0x3FF32F5CCEFFCB24), reinterpret<f64>(0xBFC73CB83C627000),\n  reinterpret<f64>(0x3FF3187775A10D49), reinterpret<f64>(0xBFC6A39A9B376000),\n  reinterpret<f64>(0x3FF301C8373E3990), reinterpret<f64>(0xBFC60B3154B7A000),\n  reinterpret<f64>(0x3FF2EB4EBB95F841), reinterpret<f64>(0xBFC5737D76243000),\n  reinterpret<f64>(0x3FF2D50A0219A9D1), reinterpret<f64>(0xBFC4DC7B8FC23000),\n  reinterpret<f64>(0x3FF2BEF9A8B7FD2A), reinterpret<f64>(0xBFC4462C51D20000),\n  reinterpret<f64>(0x3FF2A91C7A0C1BAB), reinterpret<f64>(0xBFC3B08ABC830000),\n  reinterpret<f64>(0x3FF293726014B530), reinterpret<f64>(0xBFC31B996B490000),\n  reinterpret<f64>(0x3FF27DFA5757A1F5), reinterpret<f64>(0xBFC2875490A44000),\n  reinterpret<f64>(0x3FF268B39B1D3BBF), reinterpret<f64>(0xBFC1F3B9F879A000),\n  reinterpret<f64>(0x3FF2539D838FF5BD), reinterpret<f64>(0xBFC160C8252CA000),\n  reinterpret<f64>(0x3FF23EB7AAC9083B), reinterpret<f64>(0xBFC0CE7F57F72000),\n  reinterpret<f64>(0x3FF22A012BA940B6), reinterpret<f64>(0xBFC03CDC49FEA000),\n  reinterpret<f64>(0x3FF2157996CC4132), reinterpret<f64>(0xBFBF57BDBC4B8000),\n  reinterpret<f64>(0x3FF201201DD2FC9B), reinterpret<f64>(0xBFBE370896404000),\n  reinterpret<f64>(0x3FF1ECF4494D480B), reinterpret<f64>(0xBFBD17983EF94000),\n  reinterpret<f64>(0x3FF1D8F5528F6569), reinterpret<f64>(0xBFBBF9674ED8A000),\n  reinterpret<f64>(0x3FF1C52311577E7C), reinterpret<f64>(0xBFBADC79202F6000),\n  reinterpret<f64>(0x3FF1B17C74CB26E9), reinterpret<f64>(0xBFB9C0C3E7288000),\n  reinterpret<f64>(0x3FF19E010C2C1AB6), reinterpret<f64>(0xBFB8A646B372C000),\n  reinterpret<f64>(0x3FF18AB07BB670BD), reinterpret<f64>(0xBFB78D01B3AC0000),\n  reinterpret<f64>(0x3FF1778A25EFBCB6), reinterpret<f64>(0xBFB674F145380000),\n  reinterpret<f64>(0x3FF1648D354C31DA), reinterpret<f64>(0xBFB55E0E6D878000),\n  reinterpret<f64>(0x3FF151B990275FDD), reinterpret<f64>(0xBFB4485CDEA1E000),\n  reinterpret<f64>(0x3FF13F0EA432D24C), reinterpret<f64>(0xBFB333D94D6AA000),\n  reinterpret<f64>(0x3FF12C8B7210F9DA), reinterpret<f64>(0xBFB22079F8C56000),\n  reinterpret<f64>(0x3FF11A3028ECB531), reinterpret<f64>(0xBFB10E4698622000),\n  reinterpret<f64>(0x3FF107FBDA8434AF), reinterpret<f64>(0xBFAFFA6C6AD20000),\n  reinterpret<f64>(0x3FF0F5EE0F4E6BB3), reinterpret<f64>(0xBFADDA8D4A774000),\n  reinterpret<f64>(0x3FF0E4065D2A9FCE), reinterpret<f64>(0xBFABBCECE4850000),\n  reinterpret<f64>(0x3FF0D244632CA521), reinterpret<f64>(0xBFA9A1894012C000),\n  reinterpret<f64>(0x3FF0C0A77CE2981A), reinterpret<f64>(0xBFA788583302C000),\n  reinterpret<f64>(0x3FF0AF2F83C636D1), reinterpret<f64>(0xBFA5715E67D68000),\n  reinterpret<f64>(0x3FF09DDB98A01339), reinterpret<f64>(0xBFA35C8A49658000),\n  reinterpret<f64>(0x3FF08CABAF52E7DF), reinterpret<f64>(0xBFA149E364154000),\n  reinterpret<f64>(0x3FF07B9F2F4E28FB), reinterpret<f64>(0xBF9E72C082EB8000),\n  reinterpret<f64>(0x3FF06AB58C358F19), reinterpret<f64>(0xBF9A55F152528000),\n  reinterpret<f64>(0x3FF059EEA5ECF92C), reinterpret<f64>(0xBF963D62CF818000),\n  reinterpret<f64>(0x3FF04949CDD12C90), reinterpret<f64>(0xBF9228FB8CAA0000),\n  reinterpret<f64>(0x3FF038C6C6F0ADA9), reinterpret<f64>(0xBF8C317B20F90000),\n  reinterpret<f64>(0x3FF02865137932A9), reinterpret<f64>(0xBF8419355DAA0000),\n  reinterpret<f64>(0x3FF0182427EA7348), reinterpret<f64>(0xBF781203C2EC0000),\n  reinterpret<f64>(0x3FF008040614B195), reinterpret<f64>(0xBF60040979240000),\n  reinterpret<f64>(0x3FEFE01FF726FA1A), reinterpret<f64>(0x3F6FEFF384900000),\n  reinterpret<f64>(0x3FEFA11CC261EA74), reinterpret<f64>(0x3F87DC41353D0000),\n  reinterpret<f64>(0x3FEF6310B081992E), reinterpret<f64>(0x3F93CEA3C4C28000),\n  reinterpret<f64>(0x3FEF25F63CEEADCD), reinterpret<f64>(0x3F9B9FC114890000),\n  reinterpret<f64>(0x3FEEE9C8039113E7), reinterpret<f64>(0x3FA1B0D8CE110000),\n  reinterpret<f64>(0x3FEEAE8078CBB1AB), reinterpret<f64>(0x3FA58A5BD001C000),\n  reinterpret<f64>(0x3FEE741AA29D0C9B), reinterpret<f64>(0x3FA95C8340D88000),\n  reinterpret<f64>(0x3FEE3A91830A99B5), reinterpret<f64>(0x3FAD276AEF578000),\n  reinterpret<f64>(0x3FEE01E009609A56), reinterpret<f64>(0x3FB07598E598C000),\n  reinterpret<f64>(0x3FEDCA01E577BB98), reinterpret<f64>(0x3FB253F5E30D2000),\n  reinterpret<f64>(0x3FED92F20B7C9103), reinterpret<f64>(0x3FB42EDD8B380000),\n  reinterpret<f64>(0x3FED5CAC66FB5CCE), reinterpret<f64>(0x3FB606598757C000),\n  reinterpret<f64>(0x3FED272CAA5EDE9D), reinterpret<f64>(0x3FB7DA76356A0000),\n  reinterpret<f64>(0x3FECF26E3E6B2CCD), reinterpret<f64>(0x3FB9AB434E1C6000),\n  reinterpret<f64>(0x3FECBE6DA2A77902), reinterpret<f64>(0x3FBB78C7BB0D6000),\n  reinterpret<f64>(0x3FEC8B266D37086D), reinterpret<f64>(0x3FBD431332E72000),\n  reinterpret<f64>(0x3FEC5894BD5D5804), reinterpret<f64>(0x3FBF0A3171DE6000),\n  reinterpret<f64>(0x3FEC26B533BB9F8C), reinterpret<f64>(0x3FC067152B914000),\n  reinterpret<f64>(0x3FEBF583EEECE73F), reinterpret<f64>(0x3FC147858292B000),\n  reinterpret<f64>(0x3FEBC4FD75DB96C1), reinterpret<f64>(0x3FC2266ECDCA3000),\n  reinterpret<f64>(0x3FEB951E0C864A28), reinterpret<f64>(0x3FC303D7A6C55000),\n  reinterpret<f64>(0x3FEB65E2C5EF3E2C), reinterpret<f64>(0x3FC3DFC33C331000),\n  reinterpret<f64>(0x3FEB374867C9888B), reinterpret<f64>(0x3FC4BA366B7A8000),\n  reinterpret<f64>(0x3FEB094B211D304A), reinterpret<f64>(0x3FC5933928D1F000),\n  reinterpret<f64>(0x3FEADBE885F2EF7E), reinterpret<f64>(0x3FC66ACD2418F000),\n  reinterpret<f64>(0x3FEAAF1D31603DA2), reinterpret<f64>(0x3FC740F8EC669000),\n  reinterpret<f64>(0x3FEA82E63FD358A7), reinterpret<f64>(0x3FC815C0F51AF000),\n  reinterpret<f64>(0x3FEA5740EF09738B), reinterpret<f64>(0x3FC8E92954F68000),\n  reinterpret<f64>(0x3FEA2C2A90AB4B27), reinterpret<f64>(0x3FC9BB3602F84000),\n  reinterpret<f64>(0x3FEA01A01393F2D1), reinterpret<f64>(0x3FCA8BED1C2C0000),\n  reinterpret<f64>(0x3FE9D79F24DB3C1B), reinterpret<f64>(0x3FCB5B515C01D000),\n  reinterpret<f64>(0x3FE9AE2505C7B190), reinterpret<f64>(0x3FCC2967CCBCC000),\n  reinterpret<f64>(0x3FE9852EF297CE2F), reinterpret<f64>(0x3FCCF635D5486000),\n  reinterpret<f64>(0x3FE95CBAEEA44B75), reinterpret<f64>(0x3FCDC1BD3446C000),\n  reinterpret<f64>(0x3FE934C69DE74838), reinterpret<f64>(0x3FCE8C01B8CFE000),\n  reinterpret<f64>(0x3FE90D4F2F6752E6), reinterpret<f64>(0x3FCF5509C0179000),\n  reinterpret<f64>(0x3FE8E6528EFFD79D), reinterpret<f64>(0x3FD00E6C121FB800),\n  reinterpret<f64>(0x3FE8BFCE9FCC007C), reinterpret<f64>(0x3FD071B80E93D000),\n  reinterpret<f64>(0x3FE899C0DABEC30E), reinterpret<f64>(0x3FD0D46B9E867000),\n  reinterpret<f64>(0x3FE87427AA2317FB), reinterpret<f64>(0x3FD13687334BD000),\n  reinterpret<f64>(0x3FE84F00ACB39A08), reinterpret<f64>(0x3FD1980D67234800),\n  reinterpret<f64>(0x3FE82A49E8653E55), reinterpret<f64>(0x3FD1F8FFE0CC8000),\n  reinterpret<f64>(0x3FE8060195F40260), reinterpret<f64>(0x3FD2595FD7636800),\n  reinterpret<f64>(0x3FE7E22563E0A329), reinterpret<f64>(0x3FD2B9300914A800),\n  reinterpret<f64>(0x3FE7BEB377DCB5AD), reinterpret<f64>(0x3FD3187210436000),\n  reinterpret<f64>(0x3FE79BAA679725C2), reinterpret<f64>(0x3FD377266DEC1800),\n  reinterpret<f64>(0x3FE77907F2170657), reinterpret<f64>(0x3FD3D54FFBAF3000),\n  reinterpret<f64>(0x3FE756CADBD6130C), reinterpret<f64>(0x3FD432EEE32FE000)\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data<f64>([\n  //               chi                ,                  clo\n  reinterpret<f64>(0x3FE61000014FB66B), reinterpret<f64>(0x3C7E026C91425B3C),\n  reinterpret<f64>(0x3FE63000034DB495), reinterpret<f64>(0x3C8DBFEA48005D41),\n  reinterpret<f64>(0x3FE650000D94D478), reinterpret<f64>(0x3C8E7FA786D6A5B7),\n  reinterpret<f64>(0x3FE67000074E6FAD), reinterpret<f64>(0x3C61FCEA6B54254C),\n  reinterpret<f64>(0x3FE68FFFFEDF0FAE), reinterpret<f64>(0xBC7C7E274C590EFD),\n  reinterpret<f64>(0x3FE6B0000763C5BC), reinterpret<f64>(0xBC8AC16848DCDA01),\n  reinterpret<f64>(0x3FE6D0001E5CC1F6), reinterpret<f64>(0x3C833F1C9D499311),\n  reinterpret<f64>(0x3FE6EFFFEB05F63E), reinterpret<f64>(0xBC7E80041AE22D53),\n  reinterpret<f64>(0x3FE710000E869780), reinterpret<f64>(0x3C7BFF6671097952),\n  reinterpret<f64>(0x3FE72FFFFC67E912), reinterpret<f64>(0x3C8C00E226BD8724),\n  reinterpret<f64>(0x3FE74FFFDF81116A), reinterpret<f64>(0xBC6E02916EF101D2),\n  reinterpret<f64>(0x3FE770000F679C90), reinterpret<f64>(0xBC67FC71CD549C74),\n  reinterpret<f64>(0x3FE78FFFFA7EC835), reinterpret<f64>(0x3C81BEC19EF50483),\n  reinterpret<f64>(0x3FE7AFFFFE20C2E6), reinterpret<f64>(0xBC707E1729CC6465),\n  reinterpret<f64>(0x3FE7CFFFED3FC900), reinterpret<f64>(0xBC808072087B8B1C),\n  reinterpret<f64>(0x3FE7EFFFE9261A76), reinterpret<f64>(0x3C8DC0286D9DF9AE),\n  reinterpret<f64>(0x3FE81000049CA3E8), reinterpret<f64>(0x3C897FD251E54C33),\n  reinterpret<f64>(0x3FE8300017932C8F), reinterpret<f64>(0xBC8AFEE9B630F381),\n  reinterpret<f64>(0x3FE850000633739C), reinterpret<f64>(0x3C89BFBF6B6535BC),\n  reinterpret<f64>(0x3FE87000204289C6), reinterpret<f64>(0xBC8BBF65F3117B75),\n  reinterpret<f64>(0x3FE88FFFEBF57904), reinterpret<f64>(0xBC89006EA23DCB57),\n  reinterpret<f64>(0x3FE8B00022BC04DF), reinterpret<f64>(0xBC7D00DF38E04B0A),\n  reinterpret<f64>(0x3FE8CFFFE50C1B8A), reinterpret<f64>(0xBC88007146FF9F05),\n  reinterpret<f64>(0x3FE8EFFFFC918E43), reinterpret<f64>(0x3C83817BD07A7038),\n  reinterpret<f64>(0x3FE910001EFA5FC7), reinterpret<f64>(0x3C893E9176DFB403),\n  reinterpret<f64>(0x3FE9300013467BB9), reinterpret<f64>(0x3C7F804E4B980276),\n  reinterpret<f64>(0x3FE94FFFE6EE076F), reinterpret<f64>(0xBC8F7EF0D9FF622E),\n  reinterpret<f64>(0x3FE96FFFDE3C12D1), reinterpret<f64>(0xBC7082AA962638BA),\n  reinterpret<f64>(0x3FE98FFFF4458A0D), reinterpret<f64>(0xBC87801B9164A8EF),\n  reinterpret<f64>(0x3FE9AFFFDD982E3E), reinterpret<f64>(0xBC8740E08A5A9337),\n  reinterpret<f64>(0x3FE9CFFFED49FB66), reinterpret<f64>(0x3C3FCE08C19BE000),\n  reinterpret<f64>(0x3FE9F00020F19C51), reinterpret<f64>(0xBC8A3FAA27885B0A),\n  reinterpret<f64>(0x3FEA10001145B006), reinterpret<f64>(0x3C74FF489958DA56),\n  reinterpret<f64>(0x3FEA300007BBF6FA), reinterpret<f64>(0x3C8CBEAB8A2B6D18),\n  reinterpret<f64>(0x3FEA500010971D79), reinterpret<f64>(0x3C88FECADD787930),\n  reinterpret<f64>(0x3FEA70001DF52E48), reinterpret<f64>(0xBC8F41763DD8ABDB),\n  reinterpret<f64>(0x3FEA90001C593352), reinterpret<f64>(0xBC8EBF0284C27612),\n  reinterpret<f64>(0x3FEAB0002A4F3E4B), reinterpret<f64>(0xBC69FD043CFF3F5F),\n  reinterpret<f64>(0x3FEACFFFD7AE1ED1), reinterpret<f64>(0xBC823EE7129070B4),\n  reinterpret<f64>(0x3FEAEFFFEE510478), reinterpret<f64>(0x3C6A063EE00EDEA3),\n  reinterpret<f64>(0x3FEB0FFFDB650D5B), reinterpret<f64>(0x3C5A06C8381F0AB9),\n  reinterpret<f64>(0x3FEB2FFFFEAACA57), reinterpret<f64>(0xBC79011E74233C1D),\n  reinterpret<f64>(0x3FEB4FFFD995BADC), reinterpret<f64>(0xBC79FF1068862A9F),\n  reinterpret<f64>(0x3FEB7000249E659C), reinterpret<f64>(0x3C8AFF45D0864F3E),\n  reinterpret<f64>(0x3FEB8FFFF9871640), reinterpret<f64>(0x3C7CFE7796C2C3F9),\n  reinterpret<f64>(0x3FEBAFFFD204CB4F), reinterpret<f64>(0xBC63FF27EEF22BC4),\n  reinterpret<f64>(0x3FEBCFFFD2415C45), reinterpret<f64>(0xBC6CFFB7EE3BEA21),\n  reinterpret<f64>(0x3FEBEFFFF86309DF), reinterpret<f64>(0xBC814103972E0B5C),\n  reinterpret<f64>(0x3FEC0FFFE1B57653), reinterpret<f64>(0x3C8BC16494B76A19),\n  reinterpret<f64>(0x3FEC2FFFF1FA57E3), reinterpret<f64>(0xBC64FEEF8D30C6ED),\n  reinterpret<f64>(0x3FEC4FFFDCBFE424), reinterpret<f64>(0xBC843F68BCEC4775),\n  reinterpret<f64>(0x3FEC6FFFED54B9F7), reinterpret<f64>(0x3C847EA3F053E0EC),\n  reinterpret<f64>(0x3FEC8FFFEB998FD5), reinterpret<f64>(0x3C7383068DF992F1),\n  reinterpret<f64>(0x3FECB0002125219A), reinterpret<f64>(0xBC68FD8E64180E04),\n  reinterpret<f64>(0x3FECCFFFDD94469C), reinterpret<f64>(0x3C8E7EBE1CC7EA72),\n  reinterpret<f64>(0x3FECEFFFEAFDC476), reinterpret<f64>(0x3C8EBE39AD9F88FE),\n  reinterpret<f64>(0x3FED1000169AF82B), reinterpret<f64>(0x3C757D91A8B95A71),\n  reinterpret<f64>(0x3FED30000D0FF71D), reinterpret<f64>(0x3C89C1906970C7DA),\n  reinterpret<f64>(0x3FED4FFFEA790FC4), reinterpret<f64>(0xBC580E37C558FE0C),\n  reinterpret<f64>(0x3FED70002EDC87E5), reinterpret<f64>(0xBC7F80D64DC10F44),\n  reinterpret<f64>(0x3FED900021DC82AA), reinterpret<f64>(0xBC747C8F94FD5C5C),\n  reinterpret<f64>(0x3FEDAFFFD86B0283), reinterpret<f64>(0x3C8C7F1DC521617E),\n  reinterpret<f64>(0x3FEDD000296C4739), reinterpret<f64>(0x3C88019EB2FFB153),\n  reinterpret<f64>(0x3FEDEFFFE54490F5), reinterpret<f64>(0x3C6E00D2C652CC89),\n  reinterpret<f64>(0x3FEE0FFFCDABF694), reinterpret<f64>(0xBC7F8340202D69D2),\n  reinterpret<f64>(0x3FEE2FFFDB52C8DD), reinterpret<f64>(0x3C7B00C1CA1B0864),\n  reinterpret<f64>(0x3FEE4FFFF24216EF), reinterpret<f64>(0x3C72FFA8B094AB51),\n  reinterpret<f64>(0x3FEE6FFFE88A5E11), reinterpret<f64>(0xBC57F673B1EFBE59),\n  reinterpret<f64>(0x3FEE9000119EFF0D), reinterpret<f64>(0xBC84808D5E0BC801),\n  reinterpret<f64>(0x3FEEAFFFDFA51744), reinterpret<f64>(0x3C780006D54320B5),\n  reinterpret<f64>(0x3FEED0001A127FA1), reinterpret<f64>(0xBC5002F860565C92),\n  reinterpret<f64>(0x3FEEF00007BABCC4), reinterpret<f64>(0xBC8540445D35E611),\n  reinterpret<f64>(0x3FEF0FFFF57A8D02), reinterpret<f64>(0xBC4FFB3139EF9105),\n  reinterpret<f64>(0x3FEF30001EE58AC7), reinterpret<f64>(0x3C8A81ACF2731155),\n  reinterpret<f64>(0x3FEF4FFFF5823494), reinterpret<f64>(0x3C8A3F41D4D7C743),\n  reinterpret<f64>(0x3FEF6FFFFCA94C6B), reinterpret<f64>(0xBC6202F41C987875),\n  reinterpret<f64>(0x3FEF8FFFE1F9C441), reinterpret<f64>(0x3C777DD1F477E74B),\n  reinterpret<f64>(0x3FEFAFFFD2E0E37E), reinterpret<f64>(0xBC6F01199A7CA331),\n  reinterpret<f64>(0x3FEFD0001C77E49E), reinterpret<f64>(0x3C7181EE4BCEACB1),\n  reinterpret<f64>(0x3FEFEFFFF7E0C331), reinterpret<f64>(0xBC6E05370170875A),\n  reinterpret<f64>(0x3FF00FFFF465606E), reinterpret<f64>(0xBC8A7EAD491C0ADA),\n  reinterpret<f64>(0x3FF02FFFF3867A58), reinterpret<f64>(0xBC977F69C3FCB2E0),\n  reinterpret<f64>(0x3FF04FFFFDFC0D17), reinterpret<f64>(0x3C97BFFE34CB945B),\n  reinterpret<f64>(0x3FF0700003CD4D82), reinterpret<f64>(0x3C820083C0E456CB),\n  reinterpret<f64>(0x3FF08FFFF9F2CBE8), reinterpret<f64>(0xBC6DFFDFBE37751A),\n  reinterpret<f64>(0x3FF0B000010CDA65), reinterpret<f64>(0xBC913F7FAEE626EB),\n  reinterpret<f64>(0x3FF0D00001A4D338), reinterpret<f64>(0x3C807DFA79489FF7),\n  reinterpret<f64>(0x3FF0EFFFFADAFDFD), reinterpret<f64>(0xBC77040570D66BC0),\n  reinterpret<f64>(0x3FF110000BBAFD96), reinterpret<f64>(0x3C8E80D4846D0B62),\n  reinterpret<f64>(0x3FF12FFFFAE5F45D), reinterpret<f64>(0x3C9DBFFA64FD36EF),\n  reinterpret<f64>(0x3FF150000DD59AD9), reinterpret<f64>(0x3C9A0077701250AE),\n  reinterpret<f64>(0x3FF170000F21559A), reinterpret<f64>(0x3C8DFDF9E2E3DEEE),\n  reinterpret<f64>(0x3FF18FFFFC275426), reinterpret<f64>(0x3C910030DC3B7273),\n  reinterpret<f64>(0x3FF1B000123D3C59), reinterpret<f64>(0x3C997F7980030188),\n  reinterpret<f64>(0x3FF1CFFFF8299EB7), reinterpret<f64>(0xBC65F932AB9F8C67),\n  reinterpret<f64>(0x3FF1EFFFF48AD400), reinterpret<f64>(0x3C937FBF9DA75BEB),\n  reinterpret<f64>(0x3FF210000C8B86A4), reinterpret<f64>(0x3C9F806B91FD5B22),\n  reinterpret<f64>(0x3FF2300003854303), reinterpret<f64>(0x3C93FFC2EB9FBF33),\n  reinterpret<f64>(0x3FF24FFFFFBCF684), reinterpret<f64>(0x3C7601E77E2E2E72),\n  reinterpret<f64>(0x3FF26FFFF52921D9), reinterpret<f64>(0x3C7FFCBB767F0C61),\n  reinterpret<f64>(0x3FF2900014933A3C), reinterpret<f64>(0xBC7202CA3C02412B),\n  reinterpret<f64>(0x3FF2B00014556313), reinterpret<f64>(0xBC92808233F21F02),\n  reinterpret<f64>(0x3FF2CFFFEBFE523B), reinterpret<f64>(0xBC88FF7E384FDCF2),\n  reinterpret<f64>(0x3FF2F0000BB8AD96), reinterpret<f64>(0xBC85FF51503041C5),\n  reinterpret<f64>(0x3FF30FFFFB7AE2AF), reinterpret<f64>(0xBC810071885E289D),\n  reinterpret<f64>(0x3FF32FFFFEAC5F7F), reinterpret<f64>(0xBC91FF5D3FB7B715),\n  reinterpret<f64>(0x3FF350000CA66756), reinterpret<f64>(0x3C957F82228B82BD),\n  reinterpret<f64>(0x3FF3700011FBF721), reinterpret<f64>(0x3C8000BAC40DD5CC),\n  reinterpret<f64>(0x3FF38FFFF9592FB9), reinterpret<f64>(0xBC943F9D2DB2A751),\n  reinterpret<f64>(0x3FF3B00004DDD242), reinterpret<f64>(0x3C857F6B707638E1),\n  reinterpret<f64>(0x3FF3CFFFF5B2C957), reinterpret<f64>(0x3C7A023A10BF1231),\n  reinterpret<f64>(0x3FF3EFFFEAB0B418), reinterpret<f64>(0x3C987F6D66B152B0),\n  reinterpret<f64>(0x3FF410001532AFF4), reinterpret<f64>(0x3C67F8375F198524),\n  reinterpret<f64>(0x3FF4300017478B29), reinterpret<f64>(0x3C8301E672DC5143),\n  reinterpret<f64>(0x3FF44FFFE795B463), reinterpret<f64>(0x3C89FF69B8B2895A),\n  reinterpret<f64>(0x3FF46FFFE80475E0), reinterpret<f64>(0xBC95C0B19BC2F254),\n  reinterpret<f64>(0x3FF48FFFEF6FC1E7), reinterpret<f64>(0x3C9B4009F23A2A72),\n  reinterpret<f64>(0x3FF4AFFFE5BEA704), reinterpret<f64>(0xBC94FFB7BF0D7D45),\n  reinterpret<f64>(0x3FF4D000171027DE), reinterpret<f64>(0xBC99C06471DC6A3D),\n  reinterpret<f64>(0x3FF4F0000FF03EE2), reinterpret<f64>(0x3C977F890B85531C),\n  reinterpret<f64>(0x3FF5100012DC4BD1), reinterpret<f64>(0x3C6004657166A436),\n  reinterpret<f64>(0x3FF530001605277A), reinterpret<f64>(0xBC96BFCECE233209),\n  reinterpret<f64>(0x3FF54FFFECDB704C), reinterpret<f64>(0xBC8902720505A1D7),\n  reinterpret<f64>(0x3FF56FFFEF5F54A9), reinterpret<f64>(0x3C9BBFE60EC96412),\n  reinterpret<f64>(0x3FF5900017E61012), reinterpret<f64>(0x3C887EC581AFEF90),\n  reinterpret<f64>(0x3FF5B00003C93E92), reinterpret<f64>(0xBC9F41080ABF0CC0),\n  reinterpret<f64>(0x3FF5D0001D4919BC), reinterpret<f64>(0xBC98812AFB254729),\n  reinterpret<f64>(0x3FF5EFFFE7B87A89), reinterpret<f64>(0xBC947EB780ED6904)\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n  const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n  const\n    B0  = reinterpret<f64>(0xBFE0000000000000), // -0x1p-1\n    B1  = reinterpret<f64>(0x3FD5555555555577), //  0x1.5555555555577p-2\n    B2  = reinterpret<f64>(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n    B3  = reinterpret<f64>(0x3FC999999995DD0C), //  0x1.999999995dd0cp-3\n    B4  = reinterpret<f64>(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n    B5  = reinterpret<f64>(0x3FC24924A344DE30), //  0x1.24924a344de3p-3\n    B6  = reinterpret<f64>(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n    B7  = reinterpret<f64>(0x3FBC7184282AD6CA), //  0x1.c7184282ad6cap-4\n    B8  = reinterpret<f64>(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n    B9  = reinterpret<f64>(0x3FB78182F7AFD085), //  0x1.78182f7afd085p-4\n    B10 = reinterpret<f64>(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n  const\n    A0 = reinterpret<f64>(0xBFE0000000000001),  // -0x1.0000000000001p-1\n    A1 = reinterpret<f64>(0x3FD555555551305B),  //  0x1.555555551305bp-2\n    A2 = reinterpret<f64>(0xBFCFFFFFFFEB4590),  // -0x1.fffffffeb459p-3\n    A3 = reinterpret<f64>(0x3FC999B324F10111),  //  0x1.999b324f10111p-3\n    A4 = reinterpret<f64>(0xBFC55575E506C89F);  // -0x1.55575e506c89fp-3\n\n  const\n    LO: u64 = 0x3FEE000000000000,\n    HI: u64 = 0x3FF1090000000000;\n\n  const\n    Ln2hi  = reinterpret<f64>(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n    Ln2lo  = reinterpret<f64>(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n    Ox1p27 = reinterpret<f64>(0x41A0000000000000), // 0x1p27\n    Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  var ix = reinterpret<u64>(x);\n  if (ix - LO < HI - LO) {\n    let r  = x - 1.0;\n    let r2 = r * r;\n    let r3 = r2 * r;\n    let y =\n      r3 * (B1 + r * B2 + r2 * B3 +\n      r3 * (B4 + r * B5 + r2 * B6 +\n      r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n    // Worst-case error is around 0.507 ULP\n    let w   = r * Ox1p27;\n    let rhi = r + w - w;\n    let rlo = r - rhi;\n    w = rhi * rhi * B0; // B[0] == -0.5\n    let hi = r + w;\n    let lo = r - hi + w;\n    lo += B0 * rlo * (rhi + r);\n    return y + lo + hi;\n  }\n  var top = u32(ix >> 48);\n  if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n    // x < 0x1p-1022 or inf or nan\n    if ((ix << 1) == 0) return -1.0 / (x * x);\n    if (ix == reinterpret<u64>(Infinity)) return x; // log(inf) == inf\n    if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n    // x is subnormal, normalize it\n    ix = reinterpret<u64>(x * Ox1p52);\n    ix -= u64(52) << 52;\n  }\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp  = ix - 0x3FE6000000000000;\n  var i    = <usize>((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n  var k    = <i64>tmp >> 52;\n  var iz   = ix - (tmp & (u64(0xFFF) << 52));\n\n  var invc = load<f64>(LOG_DATA_TAB1 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].invc;\n  var logc = load<f64>(LOG_DATA_TAB1 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].logc;\n  var z    = reinterpret<f64>(iz);\n\n  // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n  // r ~= z/c - 1, |r| < 1/(2*N)\n  // #if __FP_FAST_FMA\n  // \t// rounding error: 0x1p-55/N\n  // \tr = __builtin_fma(z, invc, -1.0);\n  // #else\n  // rounding error: 0x1p-55/N + 0x1p-66\n  const chi = load<f64>(LOG_DATA_TAB2 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T2[i].chi\n  const clo = load<f64>(LOG_DATA_TAB2 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T2[i].clo\n  var r = (z - chi - clo) * invc;\n  // #endif\n  var kd = <f64>k;\n\n  // hi + lo = r + log(c) + k*Ln2\n  var w  = kd * Ln2hi + logc;\n  var hi = w + r;\n  var lo = w - hi + r + kd * Ln2lo;\n\n  // log(x) = lo + (log1p(r) - r) + hi\n  var r2 = r * r; // rounding error: 0x1p-54/N^2\n  // Worst case error if |y| > 0x1p-5:\n  // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n  // Worst case error if |y| > 0x1p-4:\n  // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n  return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n  x = 2^k z\n  log(x) = k ln2 + log(c) + log(z/c)\n  log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = round(0x1p43*log(c))/0x1p43\n  tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n  1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data<f64>([\n  //             invc                 ,pad,               logc                 ,               logctail\n  reinterpret<f64>(0x3FF6A00000000000), 0, reinterpret<f64>(0xBFD62C82F2B9C800), reinterpret<f64>(0x3CFAB42428375680),\n  reinterpret<f64>(0x3FF6800000000000), 0, reinterpret<f64>(0xBFD5D1BDBF580800), reinterpret<f64>(0xBD1CA508D8E0F720),\n  reinterpret<f64>(0x3FF6600000000000), 0, reinterpret<f64>(0xBFD5767717455800), reinterpret<f64>(0xBD2362A4D5B6506D),\n  reinterpret<f64>(0x3FF6400000000000), 0, reinterpret<f64>(0xBFD51AAD872DF800), reinterpret<f64>(0xBCE684E49EB067D5),\n  reinterpret<f64>(0x3FF6200000000000), 0, reinterpret<f64>(0xBFD4BE5F95777800), reinterpret<f64>(0xBD041B6993293EE0),\n  reinterpret<f64>(0x3FF6000000000000), 0, reinterpret<f64>(0xBFD4618BC21C6000), reinterpret<f64>(0x3D13D82F484C84CC),\n  reinterpret<f64>(0x3FF5E00000000000), 0, reinterpret<f64>(0xBFD404308686A800), reinterpret<f64>(0x3CDC42F3ED820B3A),\n  reinterpret<f64>(0x3FF5C00000000000), 0, reinterpret<f64>(0xBFD3A64C55694800), reinterpret<f64>(0x3D20B1C686519460),\n  reinterpret<f64>(0x3FF5A00000000000), 0, reinterpret<f64>(0xBFD347DD9A988000), reinterpret<f64>(0x3D25594DD4C58092),\n  reinterpret<f64>(0x3FF5800000000000), 0, reinterpret<f64>(0xBFD2E8E2BAE12000), reinterpret<f64>(0x3D267B1E99B72BD8),\n  reinterpret<f64>(0x3FF5600000000000), 0, reinterpret<f64>(0xBFD2895A13DE8800), reinterpret<f64>(0x3D15CA14B6CFB03F),\n  reinterpret<f64>(0x3FF5600000000000), 0, reinterpret<f64>(0xBFD2895A13DE8800), reinterpret<f64>(0x3D15CA14B6CFB03F),\n  reinterpret<f64>(0x3FF5400000000000), 0, reinterpret<f64>(0xBFD22941FBCF7800), reinterpret<f64>(0xBD165A242853DA76),\n  reinterpret<f64>(0x3FF5200000000000), 0, reinterpret<f64>(0xBFD1C898C1699800), reinterpret<f64>(0xBD1FAFBC68E75404),\n  reinterpret<f64>(0x3FF5000000000000), 0, reinterpret<f64>(0xBFD1675CABABA800), reinterpret<f64>(0x3D1F1FC63382A8F0),\n  reinterpret<f64>(0x3FF4E00000000000), 0, reinterpret<f64>(0xBFD1058BF9AE4800), reinterpret<f64>(0xBD26A8C4FD055A66),\n  reinterpret<f64>(0x3FF4C00000000000), 0, reinterpret<f64>(0xBFD0A324E2739000), reinterpret<f64>(0xBD0C6BEE7EF4030E),\n  reinterpret<f64>(0x3FF4A00000000000), 0, reinterpret<f64>(0xBFD0402594B4D000), reinterpret<f64>(0xBCF036B89EF42D7F),\n  reinterpret<f64>(0x3FF4A00000000000), 0, reinterpret<f64>(0xBFD0402594B4D000), reinterpret<f64>(0xBCF036B89EF42D7F),\n  reinterpret<f64>(0x3FF4800000000000), 0, reinterpret<f64>(0xBFCFB9186D5E4000), reinterpret<f64>(0x3D0D572AAB993C87),\n  reinterpret<f64>(0x3FF4600000000000), 0, reinterpret<f64>(0xBFCEF0ADCBDC6000), reinterpret<f64>(0x3D2B26B79C86AF24),\n  reinterpret<f64>(0x3FF4400000000000), 0, reinterpret<f64>(0xBFCE27076E2AF000), reinterpret<f64>(0xBD172F4F543FFF10),\n  reinterpret<f64>(0x3FF4200000000000), 0, reinterpret<f64>(0xBFCD5C216B4FC000), reinterpret<f64>(0x3D21BA91BBCA681B),\n  reinterpret<f64>(0x3FF4000000000000), 0, reinterpret<f64>(0xBFCC8FF7C79AA000), reinterpret<f64>(0x3D27794F689F8434),\n  reinterpret<f64>(0x3FF4000000000000), 0, reinterpret<f64>(0xBFCC8FF7C79AA000), reinterpret<f64>(0x3D27794F689F8434),\n  reinterpret<f64>(0x3FF3E00000000000), 0, reinterpret<f64>(0xBFCBC286742D9000), reinterpret<f64>(0x3D194EB0318BB78F),\n  reinterpret<f64>(0x3FF3C00000000000), 0, reinterpret<f64>(0xBFCAF3C94E80C000), reinterpret<f64>(0x3CBA4E633FCD9066),\n  reinterpret<f64>(0x3FF3A00000000000), 0, reinterpret<f64>(0xBFCA23BC1FE2B000), reinterpret<f64>(0xBD258C64DC46C1EA),\n  reinterpret<f64>(0x3FF3A00000000000), 0, reinterpret<f64>(0xBFCA23BC1FE2B000), reinterpret<f64>(0xBD258C64DC46C1EA),\n  reinterpret<f64>(0x3FF3800000000000), 0, reinterpret<f64>(0xBFC9525A9CF45000), reinterpret<f64>(0xBD2AD1D904C1D4E3),\n  reinterpret<f64>(0x3FF3600000000000), 0, reinterpret<f64>(0xBFC87FA06520D000), reinterpret<f64>(0x3D2BBDBF7FDBFA09),\n  reinterpret<f64>(0x3FF3400000000000), 0, reinterpret<f64>(0xBFC7AB890210E000), reinterpret<f64>(0x3D2BDB9072534A58),\n  reinterpret<f64>(0x3FF3400000000000), 0, reinterpret<f64>(0xBFC7AB890210E000), reinterpret<f64>(0x3D2BDB9072534A58),\n  reinterpret<f64>(0x3FF3200000000000), 0, reinterpret<f64>(0xBFC6D60FE719D000), reinterpret<f64>(0xBD10E46AA3B2E266),\n  reinterpret<f64>(0x3FF3000000000000), 0, reinterpret<f64>(0xBFC5FF3070A79000), reinterpret<f64>(0xBD1E9E439F105039),\n  reinterpret<f64>(0x3FF3000000000000), 0, reinterpret<f64>(0xBFC5FF3070A79000), reinterpret<f64>(0xBD1E9E439F105039),\n  reinterpret<f64>(0x3FF2E00000000000), 0, reinterpret<f64>(0xBFC526E5E3A1B000), reinterpret<f64>(0xBD20DE8B90075B8F),\n  reinterpret<f64>(0x3FF2C00000000000), 0, reinterpret<f64>(0xBFC44D2B6CCB8000), reinterpret<f64>(0x3D170CC16135783C),\n  reinterpret<f64>(0x3FF2C00000000000), 0, reinterpret<f64>(0xBFC44D2B6CCB8000), reinterpret<f64>(0x3D170CC16135783C),\n  reinterpret<f64>(0x3FF2A00000000000), 0, reinterpret<f64>(0xBFC371FC201E9000), reinterpret<f64>(0x3CF178864D27543A),\n  reinterpret<f64>(0x3FF2800000000000), 0, reinterpret<f64>(0xBFC29552F81FF000), reinterpret<f64>(0xBD248D301771C408),\n  reinterpret<f64>(0x3FF2600000000000), 0, reinterpret<f64>(0xBFC1B72AD52F6000), reinterpret<f64>(0xBD2E80A41811A396),\n  reinterpret<f64>(0x3FF2600000000000), 0, reinterpret<f64>(0xBFC1B72AD52F6000), reinterpret<f64>(0xBD2E80A41811A396),\n  reinterpret<f64>(0x3FF2400000000000), 0, reinterpret<f64>(0xBFC0D77E7CD09000), reinterpret<f64>(0x3D0A699688E85BF4),\n  reinterpret<f64>(0x3FF2400000000000), 0, reinterpret<f64>(0xBFC0D77E7CD09000), reinterpret<f64>(0x3D0A699688E85BF4),\n  reinterpret<f64>(0x3FF2200000000000), 0, reinterpret<f64>(0xBFBFEC9131DBE000), reinterpret<f64>(0xBD2575545CA333F2),\n  reinterpret<f64>(0x3FF2000000000000), 0, reinterpret<f64>(0xBFBE27076E2B0000), reinterpret<f64>(0x3D2A342C2AF0003C),\n  reinterpret<f64>(0x3FF2000000000000), 0, reinterpret<f64>(0xBFBE27076E2B0000), reinterpret<f64>(0x3D2A342C2AF0003C),\n  reinterpret<f64>(0x3FF1E00000000000), 0, reinterpret<f64>(0xBFBC5E548F5BC000), reinterpret<f64>(0xBD1D0C57585FBE06),\n  reinterpret<f64>(0x3FF1C00000000000), 0, reinterpret<f64>(0xBFBA926D3A4AE000), reinterpret<f64>(0x3D253935E85BAAC8),\n  reinterpret<f64>(0x3FF1C00000000000), 0, reinterpret<f64>(0xBFBA926D3A4AE000), reinterpret<f64>(0x3D253935E85BAAC8),\n  reinterpret<f64>(0x3FF1A00000000000), 0, reinterpret<f64>(0xBFB8C345D631A000), reinterpret<f64>(0x3D137C294D2F5668),\n  reinterpret<f64>(0x3FF1A00000000000), 0, reinterpret<f64>(0xBFB8C345D631A000), reinterpret<f64>(0x3D137C294D2F5668),\n  reinterpret<f64>(0x3FF1800000000000), 0, reinterpret<f64>(0xBFB6F0D28AE56000), reinterpret<f64>(0xBD269737C93373DA),\n  reinterpret<f64>(0x3FF1600000000000), 0, reinterpret<f64>(0xBFB51B073F062000), reinterpret<f64>(0x3D1F025B61C65E57),\n  reinterpret<f64>(0x3FF1600000000000), 0, reinterpret<f64>(0xBFB51B073F062000), reinterpret<f64>(0x3D1F025B61C65E57),\n  reinterpret<f64>(0x3FF1400000000000), 0, reinterpret<f64>(0xBFB341D7961BE000), reinterpret<f64>(0x3D2C5EDACCF913DF),\n  reinterpret<f64>(0x3FF1400000000000), 0, reinterpret<f64>(0xBFB341D7961BE000), reinterpret<f64>(0x3D2C5EDACCF913DF),\n  reinterpret<f64>(0x3FF1200000000000), 0, reinterpret<f64>(0xBFB16536EEA38000), reinterpret<f64>(0x3D147C5E768FA309),\n  reinterpret<f64>(0x3FF1000000000000), 0, reinterpret<f64>(0xBFAF0A30C0118000), reinterpret<f64>(0x3D2D599E83368E91),\n  reinterpret<f64>(0x3FF1000000000000), 0, reinterpret<f64>(0xBFAF0A30C0118000), reinterpret<f64>(0x3D2D599E83368E91),\n  reinterpret<f64>(0x3FF0E00000000000), 0, reinterpret<f64>(0xBFAB42DD71198000), reinterpret<f64>(0x3D1C827AE5D6704C),\n  reinterpret<f64>(0x3FF0E00000000000), 0, reinterpret<f64>(0xBFAB42DD71198000), reinterpret<f64>(0x3D1C827AE5D6704C),\n  reinterpret<f64>(0x3FF0C00000000000), 0, reinterpret<f64>(0xBFA77458F632C000), reinterpret<f64>(0xBD2CFC4634F2A1EE),\n  reinterpret<f64>(0x3FF0C00000000000), 0, reinterpret<f64>(0xBFA77458F632C000), reinterpret<f64>(0xBD2CFC4634F2A1EE),\n  reinterpret<f64>(0x3FF0A00000000000), 0, reinterpret<f64>(0xBFA39E87B9FEC000), reinterpret<f64>(0x3CF502B7F526FEAA),\n  reinterpret<f64>(0x3FF0A00000000000), 0, reinterpret<f64>(0xBFA39E87B9FEC000), reinterpret<f64>(0x3CF502B7F526FEAA),\n  reinterpret<f64>(0x3FF0800000000000), 0, reinterpret<f64>(0xBF9F829B0E780000), reinterpret<f64>(0xBD2980267C7E09E4),\n  reinterpret<f64>(0x3FF0800000000000), 0, reinterpret<f64>(0xBF9F829B0E780000), reinterpret<f64>(0xBD2980267C7E09E4),\n  reinterpret<f64>(0x3FF0600000000000), 0, reinterpret<f64>(0xBF97B91B07D58000), reinterpret<f64>(0xBD288D5493FAA639),\n  reinterpret<f64>(0x3FF0400000000000), 0, reinterpret<f64>(0xBF8FC0A8B0FC0000), reinterpret<f64>(0xBCDF1E7CF6D3A69C),\n  reinterpret<f64>(0x3FF0400000000000), 0, reinterpret<f64>(0xBF8FC0A8B0FC0000), reinterpret<f64>(0xBCDF1E7CF6D3A69C),\n  reinterpret<f64>(0x3FF0200000000000), 0, reinterpret<f64>(0xBF7FE02A6B100000), reinterpret<f64>(0xBD19E23F0DDA40E4),\n  reinterpret<f64>(0x3FF0200000000000), 0, reinterpret<f64>(0xBF7FE02A6B100000), reinterpret<f64>(0xBD19E23F0DDA40E4),\n  reinterpret<f64>(0x3FF0000000000000), 0, 0, 0,\n  reinterpret<f64>(0x3FF0000000000000), 0, 0, 0,\n  reinterpret<f64>(0x3FEFC00000000000), 0, reinterpret<f64>(0x3F80101575890000), reinterpret<f64>(0xBD10C76B999D2BE8),\n  reinterpret<f64>(0x3FEF800000000000), 0, reinterpret<f64>(0x3F90205658938000), reinterpret<f64>(0xBD23DC5B06E2F7D2),\n  reinterpret<f64>(0x3FEF400000000000), 0, reinterpret<f64>(0x3F98492528C90000), reinterpret<f64>(0xBD2AA0BA325A0C34),\n  reinterpret<f64>(0x3FEF000000000000), 0, reinterpret<f64>(0x3FA0415D89E74000), reinterpret<f64>(0x3D0111C05CF1D753),\n  reinterpret<f64>(0x3FEEC00000000000), 0, reinterpret<f64>(0x3FA466AED42E0000), reinterpret<f64>(0xBD2C167375BDFD28),\n  reinterpret<f64>(0x3FEE800000000000), 0, reinterpret<f64>(0x3FA894AA149FC000), reinterpret<f64>(0xBD197995D05A267D),\n  reinterpret<f64>(0x3FEE400000000000), 0, reinterpret<f64>(0x3FACCB73CDDDC000), reinterpret<f64>(0xBD1A68F247D82807),\n  reinterpret<f64>(0x3FEE200000000000), 0, reinterpret<f64>(0x3FAEEA31C006C000), reinterpret<f64>(0xBD0E113E4FC93B7B),\n  reinterpret<f64>(0x3FEDE00000000000), 0, reinterpret<f64>(0x3FB1973BD1466000), reinterpret<f64>(0xBD25325D560D9E9B),\n  reinterpret<f64>(0x3FEDA00000000000), 0, reinterpret<f64>(0x3FB3BDF5A7D1E000), reinterpret<f64>(0x3D2CC85EA5DB4ED7),\n  reinterpret<f64>(0x3FED600000000000), 0, reinterpret<f64>(0x3FB5E95A4D97A000), reinterpret<f64>(0xBD2C69063C5D1D1E),\n  reinterpret<f64>(0x3FED400000000000), 0, reinterpret<f64>(0x3FB700D30AEAC000), reinterpret<f64>(0x3CEC1E8DA99DED32),\n  reinterpret<f64>(0x3FED000000000000), 0, reinterpret<f64>(0x3FB9335E5D594000), reinterpret<f64>(0x3D23115C3ABD47DA),\n  reinterpret<f64>(0x3FECC00000000000), 0, reinterpret<f64>(0x3FBB6AC88DAD6000), reinterpret<f64>(0xBD1390802BF768E5),\n  reinterpret<f64>(0x3FECA00000000000), 0, reinterpret<f64>(0x3FBC885801BC4000), reinterpret<f64>(0x3D2646D1C65AACD3),\n  reinterpret<f64>(0x3FEC600000000000), 0, reinterpret<f64>(0x3FBEC739830A2000), reinterpret<f64>(0xBD2DC068AFE645E0),\n  reinterpret<f64>(0x3FEC400000000000), 0, reinterpret<f64>(0x3FBFE89139DBE000), reinterpret<f64>(0xBD2534D64FA10AFD),\n  reinterpret<f64>(0x3FEC000000000000), 0, reinterpret<f64>(0x3FC1178E8227E000), reinterpret<f64>(0x3D21EF78CE2D07F2),\n  reinterpret<f64>(0x3FEBE00000000000), 0, reinterpret<f64>(0x3FC1AA2B7E23F000), reinterpret<f64>(0x3D2CA78E44389934),\n  reinterpret<f64>(0x3FEBA00000000000), 0, reinterpret<f64>(0x3FC2D1610C868000), reinterpret<f64>(0x3D039D6CCB81B4A1),\n  reinterpret<f64>(0x3FEB800000000000), 0, reinterpret<f64>(0x3FC365FCB0159000), reinterpret<f64>(0x3CC62FA8234B7289),\n  reinterpret<f64>(0x3FEB400000000000), 0, reinterpret<f64>(0x3FC4913D8333B000), reinterpret<f64>(0x3D25837954FDB678),\n  reinterpret<f64>(0x3FEB200000000000), 0, reinterpret<f64>(0x3FC527E5E4A1B000), reinterpret<f64>(0x3D2633E8E5697DC7),\n  reinterpret<f64>(0x3FEAE00000000000), 0, reinterpret<f64>(0x3FC6574EBE8C1000), reinterpret<f64>(0x3D19CF8B2C3C2E78),\n  reinterpret<f64>(0x3FEAC00000000000), 0, reinterpret<f64>(0x3FC6F0128B757000), reinterpret<f64>(0xBD25118DE59C21E1),\n  reinterpret<f64>(0x3FEAA00000000000), 0, reinterpret<f64>(0x3FC7898D85445000), reinterpret<f64>(0xBD1C661070914305),\n  reinterpret<f64>(0x3FEA600000000000), 0, reinterpret<f64>(0x3FC8BEAFEB390000), reinterpret<f64>(0xBD073D54AAE92CD1),\n  reinterpret<f64>(0x3FEA400000000000), 0, reinterpret<f64>(0x3FC95A5ADCF70000), reinterpret<f64>(0x3D07F22858A0FF6F),\n  reinterpret<f64>(0x3FEA000000000000), 0, reinterpret<f64>(0x3FCA93ED3C8AE000), reinterpret<f64>(0xBD28724350562169),\n  reinterpret<f64>(0x3FE9E00000000000), 0, reinterpret<f64>(0x3FCB31D8575BD000), reinterpret<f64>(0xBD0C358D4EACE1AA),\n  reinterpret<f64>(0x3FE9C00000000000), 0, reinterpret<f64>(0x3FCBD087383BE000), reinterpret<f64>(0xBD2D4BC4595412B6),\n  reinterpret<f64>(0x3FE9A00000000000), 0, reinterpret<f64>(0x3FCC6FFBC6F01000), reinterpret<f64>(0xBCF1EC72C5962BD2),\n  reinterpret<f64>(0x3FE9600000000000), 0, reinterpret<f64>(0x3FCDB13DB0D49000), reinterpret<f64>(0xBD2AFF2AF715B035),\n  reinterpret<f64>(0x3FE9400000000000), 0, reinterpret<f64>(0x3FCE530EFFE71000), reinterpret<f64>(0x3CC212276041F430),\n  reinterpret<f64>(0x3FE9200000000000), 0, reinterpret<f64>(0x3FCEF5ADE4DD0000), reinterpret<f64>(0xBCCA211565BB8E11),\n  reinterpret<f64>(0x3FE9000000000000), 0, reinterpret<f64>(0x3FCF991C6CB3B000), reinterpret<f64>(0x3D1BCBECCA0CDF30),\n  reinterpret<f64>(0x3FE8C00000000000), 0, reinterpret<f64>(0x3FD07138604D5800), reinterpret<f64>(0x3CF89CDB16ED4E91),\n  reinterpret<f64>(0x3FE8A00000000000), 0, reinterpret<f64>(0x3FD0C42D67616000), reinterpret<f64>(0x3D27188B163CEAE9),\n  reinterpret<f64>(0x3FE8800000000000), 0, reinterpret<f64>(0x3FD1178E8227E800), reinterpret<f64>(0xBD2C210E63A5F01C),\n  reinterpret<f64>(0x3FE8600000000000), 0, reinterpret<f64>(0x3FD16B5CCBACF800), reinterpret<f64>(0x3D2B9ACDF7A51681),\n  reinterpret<f64>(0x3FE8400000000000), 0, reinterpret<f64>(0x3FD1BF99635A6800), reinterpret<f64>(0x3D2CA6ED5147BDB7),\n  reinterpret<f64>(0x3FE8200000000000), 0, reinterpret<f64>(0x3FD214456D0EB800), reinterpret<f64>(0x3D0A87DEBA46BAEA),\n  reinterpret<f64>(0x3FE7E00000000000), 0, reinterpret<f64>(0x3FD2BEF07CDC9000), reinterpret<f64>(0x3D2A9CFA4A5004F4),\n  reinterpret<f64>(0x3FE7C00000000000), 0, reinterpret<f64>(0x3FD314F1E1D36000), reinterpret<f64>(0xBD28E27AD3213CB8),\n  reinterpret<f64>(0x3FE7A00000000000), 0, reinterpret<f64>(0x3FD36B6776BE1000), reinterpret<f64>(0x3D116ECDB0F177C8),\n  reinterpret<f64>(0x3FE7800000000000), 0, reinterpret<f64>(0x3FD3C25277333000), reinterpret<f64>(0x3D183B54B606BD5C),\n  reinterpret<f64>(0x3FE7600000000000), 0, reinterpret<f64>(0x3FD419B423D5E800), reinterpret<f64>(0x3D08E436EC90E09D),\n  reinterpret<f64>(0x3FE7400000000000), 0, reinterpret<f64>(0x3FD4718DC271C800), reinterpret<f64>(0xBD2F27CE0967D675),\n  reinterpret<f64>(0x3FE7200000000000), 0, reinterpret<f64>(0x3FD4C9E09E173000), reinterpret<f64>(0xBD2E20891B0AD8A4),\n  reinterpret<f64>(0x3FE7000000000000), 0, reinterpret<f64>(0x3FD522AE0738A000), reinterpret<f64>(0x3D2EBE708164C759),\n  reinterpret<f64>(0x3FE6E00000000000), 0, reinterpret<f64>(0x3FD57BF753C8D000), reinterpret<f64>(0x3D1FADEDEE5D40EF),\n  reinterpret<f64>(0x3FE6C00000000000), 0, reinterpret<f64>(0x3FD5D5BDDF596000), reinterpret<f64>(0xBD0A0B2A08A465DC)\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n  var e = iy >> 52 & 0x7FF;\n  if (e < 0x3FF     ) return 0;\n  if (e > 0x3FF + 52) return 2;\n  e = u64(1) << (0x3FF + 52 - e);\n  if (iy & (e - 1)) return 0;\n  if (iy &  e     ) return 1;\n  return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n  return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n  return xflow(sign, reinterpret<f64>(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n  return xflow(sign, reinterpret<f64>(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n  return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy var log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n  const N = 1 << POW_LOG_TABLE_BITS;\n  const N_MASK = N - 1;\n\n  const\n    Ln2hi = reinterpret<f64>(0x3FE62E42FEFA3800),\n    Ln2lo = reinterpret<f64>(0x3D2EF35793C76730);\n\n  const\n    A0 = reinterpret<f64>(0xBFE0000000000000),\n    A1 = reinterpret<f64>(0xBFE5555555555560),\n    A2 = reinterpret<f64>(0x3FE0000000000006),\n    A3 = reinterpret<f64>(0x3FE999999959554E),\n    A4 = reinterpret<f64>(0xBFE555555529A47A),\n    A5 = reinterpret<f64>(0xBFF2495B9B4845E9),\n    A6 = reinterpret<f64>(0x3FF0002B8B263FC3);\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  var tmp = ix - 0x3fE6955500000000;\n  var i   = <usize>((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n  var k   = <i64>tmp >> 52;\n  var iz  = ix - (tmp & u64(0xFFF) << 52);\n  var z   = reinterpret<f64>(iz);\n  var kd  = <f64>k;\n\n  // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n  var invc     = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 0 << alignof<f64>()); // tab[i].invc\n  var logc     = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 2 << alignof<f64>()); // tab[i].logc\n  var logctail = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 3 << alignof<f64>()); // tab[i].logctail\n\n  // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n  // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n  // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n  var zhi = reinterpret<f64>((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n  var zlo = z - zhi;\n  var rhi = zhi * invc - 1.0;\n  var rlo = zlo * invc;\n  var r   = rhi + rlo;\n\n  // k * Ln2 + log(c) + r.\n  var t1  = kd * Ln2hi + logc;\n  var t2  = t1 + r;\n  var lo1 = kd * Ln2lo + logctail;\n  var lo2 = t1 - t2 + r;\n\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  var ar  = A0 * r; // A[0] = -0.5\n  var ar2 = r * ar;\n  var ar3 = r * ar2;\n  // k * Ln2 + log(c) + r + A[0] * r * r.\n  var arhi  = A0  * rhi;\n  var arhi2 = rhi * arhi;\n  var hi    = t2  + arhi2;\n  var lo3   = rlo * (ar + arhi);\n  var lo4   = t2 - hi + arhi2;\n\n  // p = log1p(r) - r - A[0] * r * r.\n  var p  = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n  var lo = lo1 + lo2 + lo3 + lo4 + p;\n  var y  = hi + lo;\n  log_tail = hi - y + lo;\n\n  return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n  const N      = 1 << EXP_TABLE_BITS;\n  const N_MASK = N - 1;\n\n  const\n    InvLn2N   = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n    NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000),     // -0x1.62e42fefa0000p-8\n    NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A),     // -0x1.cf79abc9e3b3ap-47\n    shift     = reinterpret<f64>(0x4338000000000000);     // 0x1.8p52\n\n  const\n    C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n    C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n    C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n    C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n  var abstop: u32;\n  var ki: u64, top: u64, sbits: u64;\n  var idx: usize;\n  // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n  var kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n  var ux = reinterpret<u64>(x);\n  abstop = <u32>(ux >> 52) & 0x7FF;\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) {\n      // Avoid spurious underflow for tiny x.\n      // Note: 0 is common input.\n      return select(-1.0, 1.0, sign_bias);\n    }\n    if (abstop >= 0x409) { // top12(1024.0)\n      // Note: inf and nan are already handled.\n      return ux >> 63 ? uflow(sign_bias) : oflow(sign_bias);\n    }\n    // Large x is special cased below.\n    abstop = 0;\n  }\n\n  // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n  // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n  z = InvLn2N * x;\n\n  // #if TOINT_INTRINSICS\n  //   kd = roundtoint(z);\n  //   ki = converttoint(z);\n  // #elif EXP_USE_TOINT_NARROW\n  //   // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n  //   kd = eval_as_double(z + shift);\n  //   ki = asuint64(kd) >> 16;\n  //   kd = (double_t)(int32_t)ki;\n  // #else\n  // z - kd is in [-1, 1] in non-nearest rounding modes\n  kd  = z + shift;\n  ki  = reinterpret<u64>(kd);\n  kd -= shift;\n  // #endif\n  r = x + kd * NegLn2hiN + kd * NegLn2loN;\n  // The code assumes 2^-200 < |xtail| < 2^-8/N\n  r += xtail;\n  // 2^(k/N) ~= scale * (1 + tail)\n  idx = <usize>((ki & N_MASK) << 1);\n  top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n  tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>())));\n  // This is only a valid scale when -1023*N < k < 1024*N\n  sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top;\n  // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  r2 = r * r;\n  // Without fma the worst case error is 0.25/N ulp larger.\n  // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n  tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase(tmp, sbits, ki);\n  scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n  // is no spurious underflow here even without fma.\n  return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n  const Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  var sign_bias: u32 = 0;\n  var ix = reinterpret<u64>(x);\n  var iy = reinterpret<u64>(y);\n  var topx = ix >> 52;\n  var topy = iy >> 52;\n\n  if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n    // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n    // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n    // Special cases: (x < 0x1p-126 or inf or nan) or\n    // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n    if (zeroinfnan(iy)) {\n      if ((iy << 1) == 0) return 1.0;\n      if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n      if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n      if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n      if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n      return y * y;\n    }\n    if (zeroinfnan(ix)) {\n      let x2 = x * x;\n      if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n      return iy >> 63 ? 1 / x2 : x2;\n    }\n    // Here x and y are non-zero finite\n    if (ix >> 63) {\n      // Finite x < 0\n      let yint = checkint(iy);\n      if (yint == 0) return (x - x) / (x - x);\n      if (yint == 1) sign_bias = SIGN_BIAS;\n      ix   &= 0x7FFFFFFFFFFFFFFF;\n      topx &= 0x7FF;\n    }\n    if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n      // Note: sign_bias == 0 here because y is not odd.\n      if (ix == 0x3FF0000000000000) return 1;\n      if ((topy & 0x7FF) < 0x3BE)   return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n      return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n    }\n    if (topx == 0) {\n      // Normalize subnormal x so exponent becomes negative.\n      ix = reinterpret<u64>(x * Ox1p52);\n      ix &= 0x7FFFFFFFFFFFFFFF;\n      ix -= u64(52) << 52;\n    }\n  }\n\n  var hi = log_inline(ix);\n  var lo = log_tail;\n  var ehi: f64, elo: f64;\n  // #if __FP_FAST_FMA\n  //   ehi = y * hi;\n  //   elo = y * lo + __builtin_fma(y, hi, -ehi);\n  // #else\n  var yhi = reinterpret<f64>(iy & 0xFFFFFFFFF8000000);\n  var ylo = y - yhi;\n  var lhi = reinterpret<f64>(reinterpret<u64>(hi) & 0xFFFFFFFFF8000000);\n  var llo = hi - lhi + lo;\n  ehi = yhi * lhi;\n  elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n  // #endif\n  return exp_inline(ehi, elo, sign_bias);\n}\n","import * as JSMath from \"./bindings/Math\";\nexport { JSMath };\n\nimport {\n  pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n  powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n  abs as builtin_abs,\n  ceil as builtin_ceil,\n  clz as builtin_clz,\n  copysign as builtin_copysign,\n  floor as builtin_floor,\n  max as builtin_max,\n  min as builtin_min,\n  sqrt as builtin_sqrt,\n  trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy var rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data<u64>([\n  0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n  0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n  0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n  0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n  0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n  0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n  const                   // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n    pS0 = reinterpret<f64>(0x3FC5555555555555), //  1.66666666666666657415e-01\n    pS1 = reinterpret<f64>(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n    pS2 = reinterpret<f64>(0x3FC9C1550E884455), //  2.01212532134862925881e-01\n    pS3 = reinterpret<f64>(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n    pS4 = reinterpret<f64>(0x3F49EFE07501B288), //  7.91534994289814532176e-04\n    pS5 = reinterpret<f64>(0x3F023DE10DFDF709), //  3.47933107596021167570e-05\n    qS1 = reinterpret<f64>(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n    qS2 = reinterpret<f64>(0x40002AE59C598AC8), //  2.02094576023350569471e+00\n    qS3 = reinterpret<f64>(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n    qS4 = reinterpret<f64>(0x3FB3B8C5B12E9282); //  7.70381505559019352791e-02\n\n  var p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n  var q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n  return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n  const                       // see: musl/src/math/__expo2.c\n    k    = <u32>2043,\n    kln2 = reinterpret<f64>(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n  var scale = reinterpret<f64>(<u64>((<u32>0x3FF + k / 2) << 20) << 32);\n  // in directed rounding correct sign before rounding or overflow is important\n  return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n  // Bits of π/4\n  const p0: u64 = 0xC4C6628B80DC1CD1;\n  const p1: u64 = 0xC90FDAA22168C234;\n\n  const Ox1p_64 = reinterpret<f64>(0x3BF0000000000000); // 0x1p-64\n  const Ox1p_75 = reinterpret<f64>(0x3B40000000000000); // 0x1p-75\n\n  var shift = clz(q1);\n\n  q1 = q1 << shift | q0 >> (64 - shift);\n  q0 <<= shift;\n\n  var lo = umuldi(p1, q1);\n  var hi = res128_hi;\n\n  var ahi = hi >> 11;\n  var alo = lo >> 11 | hi << 53;\n  var blo = <u64>(Ox1p_75 * <f64>p0 * <f64>q1 + Ox1p_75 * <f64>p1 * <f64>q0);\n\n  rempio2_y0 = <f64>(ahi + u64(lo < blo));\n  rempio2_y1 = Ox1p_64 * <f64>(alo + blo);\n\n  return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n  var u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n  u1 = u & 0xFFFFFFFF;\n  v1 = v & 0xFFFFFFFF;\n\n  u >>= 32;\n  v >>= 32;\n\n  t  = u1 * v1;\n  w0 = t & 0xFFFFFFFF;\n  t  = u * v1 + (t >> 32);\n  w1 = t >> 32;\n  t  = u1 * v + (t & 0xFFFFFFFF);\n\n  res128_hi = u * v + w1 + (t >> 32);\n  return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n  var magnitude = u & 0x7FFFFFFFFFFFFFFF;\n  var offset = (magnitude >> 52) - 1045;\n  var shift  = offset & 63;\n  var tblPtr = PIO2_TABLE + (<i32>(offset >> 6) << 3);\n  var s0: u64, s1: u64, s2: u64;\n\n  var b0 = load<u64>(tblPtr, 0 << 3);\n  var b1 = load<u64>(tblPtr, 1 << 3);\n  var b2 = load<u64>(tblPtr, 2 << 3);\n\n  // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n  if (shift) {\n    let rshift = 64 - shift;\n    let b3 = load<u64>(tblPtr, 3 << 3);\n    s0 = b1 >> rshift | b0 << shift;\n    s1 = b2 >> rshift | b1 << shift;\n    s2 = b3 >> rshift | b2 << shift;\n  } else {\n    s0 = b0;\n    s1 = b1;\n    s2 = b2;\n  }\n\n  var significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n  // First 128 bits of fractional part of x/(2π)\n  var blo = umuldi(s1, significand);\n  var bhi = res128_hi;\n\n  var ahi = s0 * significand;\n  var clo = (s2 >> 32) * (significand >> 32);\n  var plo = blo + clo;\n  var phi = ahi + bhi + u64(plo < clo);\n\n  // r: u128 = p << 2\n  var rlo = plo << 2;\n  var rhi = phi << 2 | plo >> 62;\n\n  // s: i128 = r >> 127\n  var slo = <i64>rhi >> 63;\n  var shi = slo >> 1;\n  var q   = (<i64>phi >> 62) - slo;\n\n  var shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n  var signbit = (u ^ rhi) & 0x8000000000000000;\n  var coeff   = reinterpret<f64>(shifter | signbit);\n\n  rempio2_y0 *= coeff;\n  rempio2_y1 *= coeff;\n\n  return <i32>q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n  const\n    pio2_1  = reinterpret<f64>(0x3FF921FB54400000), // 1.57079632673412561417e+00\n    pio2_1t = reinterpret<f64>(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n    pio2_2  = reinterpret<f64>(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n    pio2_2t = reinterpret<f64>(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n    pio2_3  = reinterpret<f64>(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n    pio2_3t = reinterpret<f64>(0x397B839A252049C1), // 8.47842766036889956997e-32\n    invpio2 = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n  var ix = <u32>(u >> 32) & 0x7FFFFFFF;\n\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n      let q = 1, z: f64, y0: f64, y1: f64;\n      if (!sign) {\n        z = x - pio2_1;\n        if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n          y0 = z - pio2_1t;\n          y1 = (z - y0) - pio2_1t;\n        } else { // near pi/2, use 33+33+53 bit pi\n          z -= pio2_2;\n          y0 = z - pio2_2t;\n          y1 = (z - y0) - pio2_2t;\n        }\n      } else { // negative x\n        z = x + pio2_1;\n        if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n          y0 = z + pio2_1t;\n          y1 = (z - y0) + pio2_1t;\n        } else { // near pi/2, use 33+33+53 bit pi\n          z += pio2_2;\n          y0 = z + pio2_2t;\n          y1 = (z - y0) + pio2_2t;\n        }\n        q = -1;\n      }\n      rempio2_y0 = y0;\n      rempio2_y1 = y1;\n      return q;\n    }\n  }\n\n  if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n    // Use precise Cody Waite scheme\n    let q  = nearest(x * invpio2);\n    let r  = x - q * pio2_1;\n    let w  = q * pio2_1t; // 1st round good to 85 bit\n    let j  = ix >> 20;\n    let y0 = r - w;\n    let hi = <u32>(reinterpret<u64>(y0) >> 32);\n    let i  = j - ((hi >> 20) & 0x7FF);\n\n    if (i > 16) { // 2nd iteration needed, good to 118\n      let t = r;\n      w  = q * pio2_2;\n      r  = t - w;\n      w  = q * pio2_2t - ((t - r) - w);\n      y0 = r - w;\n      hi = <u32>(reinterpret<u64>(y0) >> 32);\n      i = j - ((hi >> 20) & 0x7FF);\n      if (i > 49) { // 3rd iteration need, 151 bits acc\n        let t = r;\n        w  = q * pio2_3;\n        r  = t - w;\n        w  = q * pio2_3t - ((t - r) - w);\n        y0 = r - w;\n      }\n    }\n    let y1 = (r - y0) - w;\n    rempio2_y0 = y0;\n    rempio2_y1 = y1;\n    return <i32>q;\n  }\n  var q = pio2_large_quot(x, u);\n  return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n  const\n    S1 = reinterpret<f64>(0xBFC5555555555549), // -1.66666666666666324348e-01\n    S2 = reinterpret<f64>(0x3F8111111110F8A6), //  8.33333333332248946124e-03\n    S3 = reinterpret<f64>(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n    S4 = reinterpret<f64>(0x3EC71DE357B1FE7D), //  2.75573137070700676789e-06\n    S5 = reinterpret<f64>(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n    S6 = reinterpret<f64>(0x3DE5D93A5ACFD57C); //  1.58969099521155010221e-10\n\n  var z = x * x;\n  var w = z * z;\n  var r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n  var v = z * x;\n  if (!iy) {\n    return x + v * (S1 + z * r);\n  } else {\n    return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n  }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n  const\n    C1 = reinterpret<f64>(0x3FA555555555554C), //  4.16666666666666019037e-02\n    C2 = reinterpret<f64>(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n    C3 = reinterpret<f64>(0x3EFA01A019CB1590), //  2.48015872894767294178e-05\n    C4 = reinterpret<f64>(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n    C5 = reinterpret<f64>(0x3E21EE9EBDB4B1C4), //  2.08757232129817482790e-09\n    C6 = reinterpret<f64>(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n  var z = x * x;\n  var w = z * z;\n  var r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n  var hz = 0.5 * z;\n  w = 1.0 - hz;\n  return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n  const\n    T0  = reinterpret<f64>(0x3FD5555555555563), //  3.33333333333334091986e-01\n    T1  = reinterpret<f64>(0x3FC111111110FE7A), //  1.33333333333201242699e-01\n    T2  = reinterpret<f64>(0x3FABA1BA1BB341FE), //  5.39682539762260521377e-02\n    T3  = reinterpret<f64>(0x3F9664F48406D637), //  2.18694882948595424599e-02\n    T4  = reinterpret<f64>(0x3F8226E3E96E8493), //  8.86323982359930005737e-03\n    T5  = reinterpret<f64>(0x3F6D6D22C9560328), //  3.59207910759131235356e-03\n    T6  = reinterpret<f64>(0x3F57DBC8FEE08315), //  1.45620945432529025516e-03\n    T7  = reinterpret<f64>(0x3F4344D8F2F26501), //  5.88041240820264096874e-04\n    T8  = reinterpret<f64>(0x3F3026F71A8D1068), //  2.46463134818469906812e-04\n    T9  = reinterpret<f64>(0x3F147E88A03792A6), //  7.81794442939557092300e-05\n    T10 = reinterpret<f64>(0x3F12B80F32F0A7E9), //  7.14072491382608190305e-05\n    T11 = reinterpret<f64>(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n    T12 = reinterpret<f64>(0x3EFB2A7074BF7AD4); //  2.59073051863633712884e-05\n\n  const\n    one    = reinterpret<f64>(0x3FF0000000000000), // 1.00000000000000000000e+00\n    pio4   = reinterpret<f64>(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n    pio4lo = reinterpret<f64>(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n  var z: f64, r: f64, v: f64, w: f64, s: f64;\n  var hx = <i32>(reinterpret<u64>(x) >> 32); // high word of x\n  var ix = hx & 0x7FFFFFFF; // high word of |x|\n  var big = ix >= 0x3FE59428;\n  if (big) { // |x| >= 0.6744\n    if (hx < 0) { x = -x, y = -y; }\n    z = pio4 - x;\n    w = pio4lo - y;\n    x = z + w;\n    y = 0.0;\n  }\n  z = x * x;\n  w = z * z;\n  r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n  v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n  s = z * x;\n  r = y + z * (s * (r + v) + y);\n  r += T0 * s;\n  w = x + r;\n  if (big) {\n    v = iy;\n    return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n  }\n  if (iy == 1) return w;\n  var a: f64, t: f64;\n  z = w;\n  z = reinterpret<f64>(reinterpret<u64>(z) & 0xFFFFFFFF00000000);\n  v = r - (z - x);  // z + v = r + x\n  t = a = -one / w; // a = -1.0 / w\n  t = reinterpret<f64>(reinterpret<u64>(t) & 0xFFFFFFFF00000000);\n  s = one + t * z;\n  return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    const inv32 = 1.0 / 4294967296;\n    return <i32><i64>(x - 4294967296 * floor(x * inv32));\n  } else {\n    let result = 0;\n    let u = reinterpret<u64>(x);\n    let e = (u >> 52) & 0x7FF;\n    if (e <= 1023 + 30) {\n      result = <i32>x;\n    } else if (e <= 1023 + 30 + 53) {\n      let v = (u & ((<u64>1 << 52) - 1)) | (<u64>1 << 52);\n      v = v << e - 1023 - 52 + 32;\n      result = <i32>(v >> 32);\n      result = select<i32>(-result, result, u >> 63);\n    }\n    return result;\n  }\n}\n\n// @ts-ignore: decorator\n@lazy var random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy var random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy var random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n  h ^= h >> 33;                     // see: https://github.com/aappleby/smhasher\n  h *= 0xFF51AFD7ED558CCD;\n  h ^= h >> 33;\n  h *= 0xC4CEB9FE1A85EC53;\n  h ^= h >> 33;\n  return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n  h += 0x6D2B79F5;\n  h  = (h ^ (h >> 15)) * (h | 1);\n  h ^= h + (h ^ (h >> 7)) * (h | 61);\n  return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const E       = reinterpret<f64>(0x4005BF0A8B145769); // 2.7182818284590452354\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN2     = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN10    = reinterpret<f64>(0x40026BB1BBB55516); // 2.30258509299404568402\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG2E   = reinterpret<f64>(0x3FF71547652B82FE); // 1.4426950408889634074\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG10E  = reinterpret<f64>(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n  // @ts-ignore: decorator\n  @lazy\n  export const PI      = reinterpret<f64>(0x400921FB54442D18); // 3.14159265358979323846\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT1_2 = reinterpret<f64>(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT2   = reinterpret<f64>(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n  // @ts-ignore: decorator\n  @lazy\n  export var sincos_sin: f64 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export var sincos_cos: f64 = 0;\n\n  // @ts-ignore: decorator\n  @inline export function abs(x: f64): f64 {\n    return builtin_abs<f64>(x);\n  }\n\n  export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f64>(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n      pio2_lo   = reinterpret<f64>(0x3C91A62633145C07), // 6.12323399573676603587e-17\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    var hx = <u32>(reinterpret<u64>(x) >> 32);\n    var ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3FF00000) {\n      let lx = <u32>reinterpret<u64>(x);\n      if ((ix - 0x3FF00000 | lx) == 0) {\n        if (hx >> 31) return 2 * pio2_hi + Ox1p_120f;\n        return 0;\n      }\n      return 0 / (x - x);\n    }\n    if (ix < 0x3FE00000) {\n      if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n      return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n    }\n    var s: f64, w: f64, z: f64;\n    if (hx >> 31) {\n      // z = (1.0 + x) * 0.5;\n      z = 0.5 + x * 0.5;\n      s = builtin_sqrt<f64>(z);\n      w = R(z) * s - pio2_lo;\n      return 2 * (pio2_hi - (s + w));\n    }\n    // z = (1.0 - x) * 0.5;\n    z = 0.5 - x * 0.5;\n    s = builtin_sqrt<f64>(z);\n    var df = reinterpret<f64>(reinterpret<u64>(s) & 0xFFFFFFFF00000000);\n    var c = (z - df * df) / (s + df);\n    w = R(z) * s + c;\n    return 2 * (df + w);\n  }\n\n  export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n    const s = reinterpret<f64>(0x3FE62E42FEFA39EF);\n    var u = reinterpret<u64>(x);\n    // Prevent propagation for all input values less than 1.0.\n    // Note musl lib didn't fix this yet.\n    if (<i64>u < 0x3FF0000000000000) return (x - x) / 0.0;\n    var e = u >> 52 & 0x7FF;\n    if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt<f64>((x - 1) * (x - 1) + 2 * (x - 1)));\n    if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt<f64>(x * x - 1)));\n    return log(x) + s;\n  }\n\n  export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f64>(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n      pio2_lo   = reinterpret<f64>(0x3C91A62633145C07), // 6.12323399573676603587e-17\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    var hx = <u32>(reinterpret<u64>(x) >> 32);\n    var ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3FF00000) {\n      let lx = <u32>reinterpret<u64>(x);\n      if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n      return 0 / (x - x);\n    }\n    if (ix < 0x3FE00000) {\n      if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n      return x + x * R(x * x);\n    }\n    // var z = (1.0 - builtin_abs<f64>(x)) * 0.5;\n    var z = 0.5 - builtin_abs<f64>(x) * 0.5;\n    var s = builtin_sqrt<f64>(z);\n    var r = R(z);\n    if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n    else {\n      let f = reinterpret<f64>(reinterpret<u64>(s) & 0xFFFFFFFF00000000);\n      let c = (z - f * f) / (s + f);\n      x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n    }\n    if (hx >> 31) return -x;\n    return x;\n  }\n\n  export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n    const c = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n    var u = reinterpret<u64>(x);\n    var e = u >> 52 & 0x7FF;\n    var y = reinterpret<f64>(u & 0x7FFFFFFFFFFFFFFF);\n    if (e >= 0x3FF + 26) y = log(y) + c;\n    else if (e >= 0x3FF + 1)  y =   log(2 * y + 1 / (builtin_sqrt<f64>(y * y + 1) + y));\n    else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt<f64>(y * y + 1) + 1));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n    const\n      atanhi0   = reinterpret<f64>(0x3FDDAC670561BB4F), //  4.63647609000806093515e-01\n      atanhi1   = reinterpret<f64>(0x3FE921FB54442D18), //  7.85398163397448278999e-01\n      atanhi2   = reinterpret<f64>(0x3FEF730BD281F69B), //  9.82793723247329054082e-01\n      atanhi3   = reinterpret<f64>(0x3FF921FB54442D18), //  1.57079632679489655800e+00\n      atanlo0   = reinterpret<f64>(0x3C7A2B7F222F65E2), //  2.26987774529616870924e-17\n      atanlo1   = reinterpret<f64>(0x3C81A62633145C07), //  3.06161699786838301793e-17\n      atanlo2   = reinterpret<f64>(0x3C7007887AF0CBBD), //  1.39033110312309984516e-17\n      atanlo3   = reinterpret<f64>(0x3C91A62633145C07), //  6.12323399573676603587e-17\n      aT0       = reinterpret<f64>(0x3FD555555555550D), //  3.33333333333329318027e-01\n      aT1       = reinterpret<f64>(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n      aT2       = reinterpret<f64>(0x3FC24924920083FF), //  1.42857142725034663711e-01\n      aT3       = reinterpret<f64>(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n      aT4       = reinterpret<f64>(0x3FB745CDC54C206E), //  9.09088713343650656196e-02\n      aT5       = reinterpret<f64>(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n      aT6       = reinterpret<f64>(0x3FB10D66A0D03D51), //  6.66107313738753120669e-02\n      aT7       = reinterpret<f64>(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n      aT8       = reinterpret<f64>(0x3FA97B4B24760DEB), //  4.97687799461593236017e-02\n      aT9       = reinterpret<f64>(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n      aT10      = reinterpret<f64>(0x3F90AD3AE322DA11), //  1.62858201153657823623e-02\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    var ix = <u32>(reinterpret<u64>(x) >> 32);\n    var sx = x;\n    ix &= 0x7FFFFFFF;\n    var z: f64;\n    if (ix >= 0x44100000) {\n      if (isNaN(x)) return x;\n      z = atanhi3 + Ox1p_120f;\n      return builtin_copysign<f64>(z, sx);\n    }\n    var id: i32;\n    if (ix < 0x3FDC0000) {\n      if (ix < 0x3E400000) return x;\n      id = -1;\n    } else {\n      x = builtin_abs<f64>(x);\n      if (ix < 0x3FF30000) {\n        if (ix < 0x3FE60000) {\n          id = 0;\n          x = (2.0 * x - 1.0) / (2.0 + x);\n        } else {\n          id = 1;\n          x = (x - 1.0) / (x + 1.0);\n        }\n      } else {\n        if (ix < 0x40038000) {\n          id = 2;\n          x = (x - 1.5) / (1.0 + 1.5 * x);\n        } else {\n          id = 3;\n          x = -1.0 / x;\n        }\n      }\n    }\n    z = x * x;\n    var w = z * z;\n    var s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n    var s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n    var s3 = x * (s1 + s2);\n    if (id < 0) return x - s3;\n    switch (id) {\n      case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n      case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n      case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n      case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n      default: unreachable();\n    }\n    return builtin_copysign<f64>(z, sx);\n  }\n\n  export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n    var u = reinterpret<u64>(x);\n    var e = u >> 52 & 0x7FF;\n    var y = builtin_abs(x);\n    if (e < 0x3FF - 1) {\n      if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n    } else {\n      y = 0.5 * log1p(2 * (y / (1 - y)));\n    }\n    return builtin_copysign<f64>(y, x);\n  }\n\n  export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n    const pi_lo = reinterpret<f64>(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n    if (isNaN(x) || isNaN(y)) return x + y;\n    var u = reinterpret<u64>(x);\n    var ix = <u32>(u >> 32);\n    var lx = <u32>u;\n    u = reinterpret<u64>(y);\n    var iy = <u32>(u >> 32);\n    var ly = <u32>u;\n    if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n    var m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n    ix = ix & 0x7FFFFFFF;\n    iy = iy & 0x7FFFFFFF;\n    if ((iy | ly) == 0) {\n      switch (m) {\n        case 0:\n        case 1: return  y;\n        case 2: return  PI;\n        case 3: return -PI;\n      }\n    }\n    if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n    if (ix == 0x7FF00000) {\n      if (iy == 0x7FF00000) {\n        let t = m & 2 ? 3 * PI / 4 : PI / 4;\n        return m & 1 ? -t : t;\n      } else {\n        let t = m & 2 ? PI : 0;\n        return m & 1 ? -t : t;\n      }\n    }\n    var z: f64;\n    if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n    if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n    else z = atan(builtin_abs<f64>(y / x));\n    switch (m) {\n      case 0: return  z;\n      case 1: return -z;\n      case 2: return PI - (z - pi_lo);\n      case 3: return (z - pi_lo) - PI;\n    }\n    unreachable();\n    return 0;\n  }\n\n  export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n    const\n      B1     = <u32>715094163,\n      B2     = <u32>696219795,\n      P0     = reinterpret<f64>(0x3FFE03E60F61E692), //  1.87595182427177009643\n      P1     = reinterpret<f64>(0xBFFE28E092F02420), // -1.88497979543377169875\n      P2     = reinterpret<f64>(0x3FF9F1604A49D6C2), //  1.621429720105354466140\n      P3     = reinterpret<f64>(0xBFE844CBBEE751D9), // -0.758397934778766047437\n      P4     = reinterpret<f64>(0x3FC2B000D4E4EDD7), //  0.145996192886612446982\n      Ox1p54 = reinterpret<f64>(0x4350000000000000); //  0x1p54\n\n    var u = reinterpret<u64>(x);\n    var hx = <u32>(u >> 32) & 0x7FFFFFFF;\n    if (hx >= 0x7FF00000) return x + x;\n    if (hx < 0x00100000) {\n      u = reinterpret<u64>(x * Ox1p54);\n      hx = <u32>(u >> 32) & 0x7FFFFFFF;\n      if (hx == 0) return x;\n      hx = hx / 3 + B2;\n    } else {\n      hx = hx / 3 + B1;\n    }\n    u &= 1 << 63;\n    u |= <u64>hx << 32;\n    var t = reinterpret<f64>(u);\n    var r = (t * t) * (t / x);\n    t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n    t = reinterpret<f64>((reinterpret<u64>(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n    var s = t * t;\n    r = x / s;\n    r = (r - t) / (2 * t + r);\n    t = t + t * r;\n    return t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function ceil(x: f64): f64 {\n    return builtin_ceil<f64>(x);\n  }\n\n  export function clz32(x: f64): f64 {\n    if (!isFinite(x)) return 32;\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    return builtin_clz(dtoi32(x));\n  }\n\n  export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n    var u  = reinterpret<u64>(x);\n    var ix = <u32>(u >> 32);\n    var sign = ix >> 31;\n\n    ix &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ix <= 0x3FE921FB) {\n      if (ix < 0x3E46A09E) {  // |x| < 2**-27 * sqrt(2)\n        return 1.0;\n      }\n      return cos_kern(x, 0);\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7FF00000) return x - x;\n\n    // argument reduction needed\n    var n  = rempio2(x, u, sign);\n    var y0 = rempio2_y0;\n    var y1 = rempio2_y1;\n\n    x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n    return (n + 1) & 2 ? -x : x;\n  }\n\n  export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n    var u = reinterpret<u64>(x);\n    u &= 0x7FFFFFFFFFFFFFFF;\n    x = reinterpret<f64>(u);\n    var w = <u32>(u >> 32);\n    var t: f64;\n    if (w < 0x3FE62E42) {\n      if (w < 0x3FF00000 - (26 << 20)) return 1;\n      t = expm1(x);\n      // return 1 + t * t / (2 * (1 + t));\n      return 1 + t * t / (2 + 2 * t);\n    }\n    if (w < 0x40862E42) {\n      t = exp(x);\n      return 0.5 * (t + 1 / t);\n    }\n    t = expo2(x, 1);\n    return t;\n  }\n\n  export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return exp_lut(x);\n    } else {\n      const\n        ln2hi     = reinterpret<f64>(0x3FE62E42FEE00000), //  6.93147180369123816490e-01\n        ln2lo     = reinterpret<f64>(0x3DEA39EF35793C76), //  1.90821492927058770002e-10\n        invln2    = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n        P1        = reinterpret<f64>(0x3FC555555555553E), //  1.66666666666666019037e-01\n        P2        = reinterpret<f64>(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n        P3        = reinterpret<f64>(0x3F11566AAF25DE2C), //  6.61375632143793436117e-05\n        P4        = reinterpret<f64>(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n        P5        = reinterpret<f64>(0x3E66376972BEA4D0), //  4.13813679705723846039e-08\n        overflow  = reinterpret<f64>(0x40862E42FEFA39EF), //  709.782712893383973096\n        underflow = reinterpret<f64>(0xC0874910D52D3051), // -745.13321910194110842\n        Ox1p1023  = reinterpret<f64>(0x7FE0000000000000); //  0x1p1023\n\n      let hx = <u32>(reinterpret<u64>(x) >> 32);\n      let sign_ = <i32>(hx >> 31);\n      hx &= 0x7FFFFFFF;\n      if (hx >= 0x4086232B) {\n        if (isNaN(x)) return x;\n        if (x > overflow)  return x * Ox1p1023;\n        if (x < underflow) return 0;\n      }\n      let hi: f64, lo: f64 = 0;\n      let k = 0;\n      if (hx > 0x3FD62E42) {\n        if (hx >= 0x3FF0A2B2) {\n          k = <i32>(invln2 * x + builtin_copysign<f64>(0.5, x));\n        } else {\n          k = 1 - (sign_ << 1);\n        }\n        hi = x - k * ln2hi;\n        lo = k * ln2lo;\n        x = hi - lo;\n      } else if (hx > 0x3E300000) {\n        hi = x;\n      } else return 1.0 + x;\n      let xs = x * x;\n      // var c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n      let xq = xs * xs;\n      let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n      let y = 1.0 + (x * c / (2 - c) - lo + hi);\n      return k == 0 ? y : scalbn(y, k);\n    }\n  }\n\n  export function exp2(x: f64): f64 {\n    return exp2_lut(x);\n  }\n\n  export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n    const\n      o_threshold = reinterpret<f64>(0x40862E42FEFA39EF), //  7.09782712893383973096e+02\n      ln2_hi      = reinterpret<f64>(0x3FE62E42FEE00000), //  6.93147180369123816490e-01\n      ln2_lo      = reinterpret<f64>(0x3DEA39EF35793C76), //  1.90821492927058770002e-10\n      invln2      = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n      Q1          = reinterpret<f64>(0xBFA11111111110F4), // -3.33333333333331316428e-02\n      Q2          = reinterpret<f64>(0x3F5A01A019FE5585), //  1.58730158725481460165e-03\n      Q3          = reinterpret<f64>(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n      Q4          = reinterpret<f64>(0x3ED0CFCA86E65239), //  4.00821782732936239552e-06\n      Q5          = reinterpret<f64>(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n      Ox1p1023    = reinterpret<f64>(0x7FE0000000000000); //  0x1p1023\n\n    var u = reinterpret<u64>(x);\n    var hx = <u32>(u >> 32 & 0x7FFFFFFF);\n    var k = 0, sign_ = <i32>(u >> 63);\n    if (hx >= 0x4043687A) {\n      if (isNaN(x)) return x;\n      if (sign_) return -1;\n      if (x > o_threshold) return x * Ox1p1023;\n    }\n    var c = 0.0, t: f64;\n    if (hx > 0x3FD62E42) {\n      k = select<i32>(\n        1 - (sign_ << 1),\n        <i32>(invln2 * x + builtin_copysign<f64>(0.5, x)),\n        hx < 0x3FF0A2B2\n      );\n      t = <f64>k;\n      let hi = x - t * ln2_hi;\n      let lo = t * ln2_lo;\n      x = hi - lo;\n      c = (hi - x) - lo;\n    } else if (hx < 0x3C900000) return x;\n    var hfx = 0.5 * x;\n    var hxs = x * hfx;\n    // var r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n    var hxq = hxs * hxs;\n    var r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n    t = 3.0 - r1 * hfx;\n    var e = hxs * ((r1 - t) / (6.0 - x * t));\n    if (k == 0) return x - (x * e - hxs);\n    e = x * (e - c) - c;\n    e -= hxs;\n    if (k == -1) return 0.5 * (x - e) - 0.5;\n    if (k == 1) {\n      if (x < -0.25) return -2.0 * (e - (x + 0.5));\n      return 1.0 + 2.0 * (x - e);\n    }\n    u = (0x3FF + k) << 52;\n    var twopk = reinterpret<f64>(u);\n    var y: f64;\n    if (k < 0 || k > 56) {\n      y = x - e + 1.0;\n      if (k == 1024) y = y * 2.0 * Ox1p1023;\n      else y = y * twopk;\n      return y - 1.0;\n    }\n    u = (0x3FF - k) << 52;\n    y = reinterpret<f64>(u);\n    if (k < 20) y = (1 - y) - e;\n    else y = 1 - (e + y);\n    return (x + y) * twopk;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function floor(x: f64): f64 {\n    return builtin_floor<f64>(x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function fround(x: f64): f64 {\n    return <f32>x;\n  }\n\n  export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n    const\n      SPLIT    = reinterpret<f64>(0x41A0000000000000) + 1, // 0x1p27 + 1\n      Ox1p700  = reinterpret<f64>(0x6BB0000000000000),\n      Ox1p_700 = reinterpret<f64>(0x1430000000000000);\n\n    var ux = reinterpret<u64>(x);\n    var uy = reinterpret<u64>(y);\n    ux &= 0x7FFFFFFFFFFFFFFF;\n    uy &= 0x7FFFFFFFFFFFFFFF;\n    if (ux < uy) {\n      let ut = ux;\n      ux = uy;\n      uy = ut;\n    }\n    var ex = <i32>(ux >> 52);\n    var ey = <i32>(uy >> 52);\n    y = reinterpret<f64>(uy);\n    if (ey == 0x7FF) return y;\n    x = reinterpret<f64>(ux);\n    if (ex == 0x7FF || uy == 0) return x;\n    if (ex - ey > 64) return x + y;\n    var z = 1.0;\n    if (ex > 0x3FF + 510) {\n      z  = Ox1p700;\n      x *= Ox1p_700;\n      y *= Ox1p_700;\n    } else if (ey < 0x3FF - 450) {\n      z  = Ox1p_700;\n      x *= Ox1p700;\n      y *= Ox1p700;\n    }\n    var c = x * SPLIT;\n    var h = x - c + c;\n    var l = x - h;\n    var hx = x * x;\n    var lx = h * h - hx + (2 * h + l) * l;\n    c = y * SPLIT;\n    h = y - c + c;\n    l = y - h;\n    var hy = y * y;\n    var ly = h * h - hy + (2 * h + l) * l;\n    return z * builtin_sqrt(ly + lx + hy + hx);\n  }\n\n  export function imul(x: f64, y: f64): f64 {\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    if (!isFinite(x + y)) return 0;\n    return dtoi32(x) * dtoi32(y);\n  }\n\n  export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log_lut(x);\n    } else {\n      const\n        ln2_hi = reinterpret<f64>(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n        ln2_lo = reinterpret<f64>(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n        Lg1    = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n        Lg2    = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n        Lg3    = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n        Lg4    = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n        Lg5    = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n        Lg6    = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n        Lg7    = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n        Ox1p54 = reinterpret<f64>(0x4350000000000000); // 0x1p54\n\n      let u = reinterpret<u64>(x);\n      let hx = <u32>(u >> 32);\n      let k = 0;\n      if (hx < 0x00100000 || <bool>(hx >> 31)) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (hx >> 31)    return (x - x) / 0.0;\n        k -= 54;\n        x *= Ox1p54;\n        u = reinterpret<u64>(x);\n        hx = <u32>(u >> 32);\n      } else if (hx >= 0x7FF00000) {\n        return x;\n      } else if (hx == 0x3FF00000 && u << 32 == 0) {\n        return 0;\n      }\n      hx += 0x3FF00000 - 0x3FE6A09E;\n      k += (<i32>hx >> 20) - 0x3FF;\n      hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n      x = reinterpret<f64>(u);\n      let f = x - 1.0;\n      let hfsq = 0.5 * f * f;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n      let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n      let r = t2 + t1;\n      let dk = <f64>k;\n      return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n    }\n  }\n\n  export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n    const\n      ivln10hi  = reinterpret<f64>(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n      ivln10lo  = reinterpret<f64>(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n      log10_2hi = reinterpret<f64>(0x3FD34413509F6000), // 3.01029995663611771306e-01\n      log10_2lo = reinterpret<f64>(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n      Lg1       = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n      Lg2       = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n      Lg3       = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n      Lg4       = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n      Lg5       = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n      Lg6       = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n      Lg7       = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n      Ox1p54    = reinterpret<f64>(0x4350000000000000); // 0x1p54\n\n    var u = reinterpret<u64>(x);\n    var hx = <u32>(u >> 32);\n    var k = 0;\n    if (hx < 0x00100000 || <bool>(hx >> 31)) {\n      if (u << 1 == 0) return -1 / (x * x);\n      if (hx >> 31) return (x - x) / 0.0;\n      k -= 54;\n      x *= Ox1p54;\n      u = reinterpret<u64>(x);\n      hx = <u32>(u >> 32);\n    } else if (hx >= 0x7FF00000) {\n      return x;\n    } else if (hx == 0x3FF00000 && u << 32 == 0) {\n      return 0;\n    }\n    hx += 0x3FF00000 - 0x3FE6A09E;\n    k += <i32>(hx >> 20) - 0x3FF;\n    hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n    u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n    x = reinterpret<f64>(u);\n    var f = x - 1.0;\n    var hfsq = 0.5 * f * f;\n    var s = f / (2.0 + f);\n    var z = s * s;\n    var w = z * z;\n    var t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n    var t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n    var r = t2 + t1;\n    var hi = f - hfsq;\n    u = reinterpret<u64>(hi);\n    u &= 0xFFFFFFFF00000000;\n    hi = reinterpret<f64>(u);\n    var lo = f - hi - hfsq + s * (hfsq + r);\n    var val_hi = hi * ivln10hi;\n    var dk = <f64>k;\n    var y = dk * log10_2hi;\n    var val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n    w = y + val_hi;\n    val_lo += (y - w) + val_hi;\n    return val_lo + w;\n  }\n\n  export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi = reinterpret<f64>(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n      ln2_lo = reinterpret<f64>(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n      Lg1    = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n      Lg2    = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n      Lg3    = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n      Lg4    = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n      Lg5    = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n      Lg6    = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n      Lg7    = reinterpret<f64>(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n    var u = reinterpret<u64>(x);\n    var hx = <u32>(u >> 32);\n    var k = 1;\n    var c = 0.0, f = 0.0;\n    if (hx < 0x3FDA827A || <bool>(hx >> 31)) {\n      if (hx >= 0xBFF00000) {\n        if (x == -1) return x / 0.0;\n        return (x - x) / 0.0;\n      }\n      if (hx << 1 < 0x3CA00000 << 1) return x;\n      if (hx <= 0xBFD2BEC4) {\n        k = 0;\n        c = 0;\n        f = x;\n      }\n    } else if (hx >= 0x7FF00000) return x;\n    if (k) {\n      u = reinterpret<u64>(1 + x);\n      let hu = <u32>(u >> 32);\n      hu += 0x3FF00000 - 0x3FE6A09E;\n      k = <i32>(hu >> 20) - 0x3FF;\n      if (k < 54) {\n        let uf = reinterpret<f64>(u);\n        c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n        c /= uf;\n      } else c = 0;\n      hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hu << 32 | (u & 0xFFFFFFFF);\n      f = reinterpret<f64>(u) - 1;\n    }\n    var hfsq = 0.5 * f * f;\n    var s = f / (2.0 + f);\n    var z = s * s;\n    var w = z * z;\n    var t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n    var t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n    var r = t2 + t1;\n    var dk = <f64>k;\n    return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n  }\n\n  export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log2_lut(x);\n    } else {\n      const\n        ivln2hi = reinterpret<f64>(0x3FF7154765200000), // 1.44269504072144627571e+00\n        ivln2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n        Lg1     = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n        Lg2     = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n        Lg3     = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n        Lg4     = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n        Lg5     = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n        Lg6     = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n        Lg7     = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n        Ox1p54  = reinterpret<f64>(0x4350000000000000); // 1p54\n\n      let u = reinterpret<u64>(x);\n      let hx = <u32>(u >> 32);\n      let k = 0;\n      if (hx < 0x00100000 || <bool>(hx >> 31)) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (hx >> 31) return (x - x) / 0.0;\n        k -= 54;\n        x *= Ox1p54;\n        u = reinterpret<u64>(x);\n        hx = <u32>(u >> 32);\n      } else if (hx >= 0x7FF00000) {\n        return x;\n      } else if (hx == 0x3FF00000 && u << 32 == 0) {\n        return 0;\n      }\n      hx += 0x3FF00000 - 0x3FE6A09E;\n      k += <i32>(hx >> 20) - 0x3FF;\n      hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n      x = reinterpret<f64>(u);\n      let f = x - 1.0;\n      let hfsq = 0.5 * f * f;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n      let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n      let r = t2 + t1;\n      let hi = f - hfsq;\n      u = reinterpret<u64>(hi);\n      u &= 0xFFFFFFFF00000000;\n      hi = reinterpret<f64>(u);\n      let lo = f - hi - hfsq + s * (hfsq + r);\n      let val_hi = hi * ivln2hi;\n      let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n      let y = <f64>k;\n      w = y + val_hi;\n      val_lo += (y - w) + val_hi;\n      val_hi = w;\n      return val_lo + val_hi;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function max(value1: f64, value2: f64): f64 {\n    return builtin_max<f64>(value1, value2);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function min(value1: f64, value2: f64): f64 {\n    return builtin_min<f64>(value1, value2);\n  }\n\n  export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n    // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n    if (builtin_abs<f64>(y) <= 2) {\n      if (y == 2.0) return x * x;\n      if (y == 0.5) {\n        return select<f64>(\n          builtin_abs<f64>(builtin_sqrt<f64>(x)),\n          Infinity,\n          x != -Infinity\n        );\n      }\n      if (y == -1.0) return 1 / x;\n      if (y == 1.0) return x;\n      if (y == 0.0) return 1.0;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      return pow_lut(x, y);\n    } else {\n      const\n        dp_h1   = reinterpret<f64>(0x3FE2B80340000000), //  5.84962487220764160156e-01\n        dp_l1   = reinterpret<f64>(0x3E4CFDEB43CFD006), //  1.35003920212974897128e-08\n        two53   = reinterpret<f64>(0x4340000000000000), //  9007199254740992.0\n        huge    = reinterpret<f64>(0x7E37E43C8800759C), //  1e+300\n        tiny    = reinterpret<f64>(0x01A56E1FC2F8F359), //  1e-300\n        L1      = reinterpret<f64>(0x3FE3333333333303), //  5.99999999999994648725e-01\n        L2      = reinterpret<f64>(0x3FDB6DB6DB6FABFF), //  4.28571428578550184252e-01\n        L3      = reinterpret<f64>(0x3FD55555518F264D), //  3.33333329818377432918e-01\n        L4      = reinterpret<f64>(0x3FD17460A91D4101), //  2.72728123808534006489e-01\n        L5      = reinterpret<f64>(0x3FCD864A93C9DB65), //  2.30660745775561754067e-01\n        L6      = reinterpret<f64>(0x3FCA7E284A454EEF), //  2.06975017800338417784e-01\n        P1      = reinterpret<f64>(0x3FC555555555553E), //  1.66666666666666019037e-01\n        P2      = reinterpret<f64>(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n        P3      = reinterpret<f64>(0x3F11566AAF25DE2C), //  6.61375632143793436117e-05\n        P4      = reinterpret<f64>(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n        P5      = reinterpret<f64>(0x3E66376972BEA4D0), //  4.13813679705723846039e-08\n        lg2     = reinterpret<f64>(0x3FE62E42FEFA39EF), //  6.93147180559945286227e-01\n        lg2_h   = reinterpret<f64>(0x3FE62E4300000000), //  6.93147182464599609375e-01\n        lg2_l   = reinterpret<f64>(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n        ovt     = reinterpret<f64>(0x3C971547652B82FE), //  8.0085662595372944372e-017\n        cp      = reinterpret<f64>(0x3FEEC709DC3A03FD), //  9.61796693925975554329e-01\n        cp_h    = reinterpret<f64>(0x3FEEC709E0000000), //  9.61796700954437255859e-01\n        cp_l    = reinterpret<f64>(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n        ivln2   = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n        ivln2_h = reinterpret<f64>(0x3FF7154760000000), //  1.44269502162933349609e+00\n        ivln2_l = reinterpret<f64>(0x3E54AE0BF85DDF44), //  1.92596299112661746887e-08\n        inv3    = reinterpret<f64>(0x3FD5555555555555); //  0.3333333333333333333333\n\n      let u_ = reinterpret<u64>(x);\n      let hx = <i32>(u_ >> 32);\n      let lx = <u32>u_;\n      u_ = reinterpret<u64>(y);\n      let hy = <i32>(u_ >> 32);\n      let ly = <u32>u_;\n      let ix = hx & 0x7FFFFFFF;\n      let iy = hy & 0x7FFFFFFF;\n      if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n      // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n      if ( // NaN if either arg is NaN\n        ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n        iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n      ) return x + y;\n      let yisint = 0, k: i32;\n      if (hx < 0) {\n        if (iy >= 0x43400000) yisint = 2;\n        else if (iy >= 0x3FF00000) {\n          k = (iy >> 20) - 0x3FF;\n          let offset = select<u32>(52, 20, k > 20) - k;\n          let Ly = select<u32>(ly, iy, k > 20);\n          let jj = Ly >> offset;\n          if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n        }\n      }\n      if (ly == 0) {\n        if (iy == 0x7FF00000) { // y is +-inf\n          if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n          else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n          else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n        }\n        if (iy == 0x3FF00000) {\n          if (hy >= 0) return x;\n          return 1 / x;\n        }\n        if (hy == 0x40000000) return x * x;\n        if (hy == 0x3FE00000) {\n          if (hx >= 0) return builtin_sqrt(x);\n        }\n      }\n      let ax = builtin_abs<f64>(x), z: f64;\n      if (lx == 0) {\n        if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n          z = ax;\n          if (hy < 0) z = 1.0 / z;\n          if (hx < 0) {\n            if (((ix - 0x3FF00000) | yisint) == 0) {\n              let d = z - z;\n              z = d / d;\n            } else if (yisint == 1) z = -z;\n          }\n          return z;\n        }\n      }\n      let s = 1.0;\n      if (hx < 0) {\n        if (yisint == 0) {\n          let d = x - x;\n          return d / d;\n        }\n        if (yisint == 1) s = -1.0;\n      }\n      let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n      let j: i32, n: i32;\n      if (iy > 0x41E00000) {\n        if (iy > 0x43F00000) {\n          if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n          if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n        }\n        if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n        if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n        t = ax - 1.0;\n        w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n        u = ivln2_h * t;\n        v = t * ivln2_l - w * ivln2;\n        t1 = u + v;\n        t1 = reinterpret<f64>(reinterpret<u64>(t1) & 0xFFFFFFFF00000000);\n        t2 = v - (t1 - u);\n      } else {\n        let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n        n = 0;\n        if (ix < 0x00100000) {\n          ax *= two53;\n          n -= 53;\n          ix = <u32>(reinterpret<u64>(ax) >> 32);\n        }\n        n += (ix >> 20) - 0x3FF;\n        j = ix & 0x000FFFFF;\n        ix = j | 0x3FF00000;\n        if (j <= 0x3988E) k = 0;\n        else if (j < 0xBB67A) k = 1;\n        else {\n          k = 0;\n          n += 1;\n          ix -= 0x00100000;\n        }\n        ax = reinterpret<f64>(reinterpret<u64>(ax) & 0xFFFFFFFF | (<u64>ix << 32));\n        let bp = select<f64>(1.5, 1.0, k); // k ? 1.5 : 1.0\n        u = ax - bp;\n        v = 1.0 / (ax + bp);\n        ss = u * v;\n        s_h = ss;\n        s_h = reinterpret<f64>(reinterpret<u64>(s_h) & 0xFFFFFFFF00000000);\n        t_h = reinterpret<f64>(<u64>(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n        t_l = ax - (t_h - bp);\n        s_l = v * ((u - s_h * t_h) - s_h * t_l);\n        s2 = ss * ss;\n        r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n        r += s_l * (s_h + ss);\n        s2 = s_h * s_h;\n        t_h = 3.0 + s2 + r;\n        t_h = reinterpret<f64>(reinterpret<u64>(t_h) & 0xFFFFFFFF00000000);\n        t_l = r - ((t_h - 3.0) - s2);\n        u = s_h * t_h;\n        v = s_l * t_h + t_l * ss;\n        p_h = u + v;\n        p_h = reinterpret<f64>(reinterpret<u64>(p_h) & 0xFFFFFFFF00000000);\n        p_l = v - (p_h - u);\n        let z_h = cp_h * p_h;\n        let dp_l = select<f64>(dp_l1, 0.0, k);\n        let z_l = cp_l * p_h + p_l * cp + dp_l;\n        t = <f64>n;\n        let dp_h = select<f64>(dp_h1, 0.0, k);\n        t1 = ((z_h + z_l) + dp_h) + t;\n        t1 = reinterpret<f64>(reinterpret<u64>(t1) & 0xFFFFFFFF00000000);\n        t2 = z_l - (((t1 - t) - dp_h) - z_h);\n      }\n      let y1 = y;\n      y1 = reinterpret<f64>(reinterpret<u64>(y1) & 0xFFFFFFFF00000000);\n      p_l = (y - y1) * t1 + y * t2;\n      p_h = y1 * t1;\n      z = p_l + p_h;\n      u_ = reinterpret<u64>(z);\n      j = <u32>(u_ >> 32);\n      let i = <i32>u_;\n      if (j >= 0x40900000) {\n        if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n        if (p_l + ovt > z - p_h) return s * huge * huge;\n      } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n        if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n        if (p_l <= z - p_h) return s * tiny * tiny;\n      }\n      i = j & 0x7FFFFFFF;\n      k = (i >> 20) - 0x3FF;\n      n = 0;\n      if (i > 0x3FE00000) {\n        n = j + (0x00100000 >> (k + 1));\n        k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n        t = 0.0;\n        t = reinterpret<f64>(<u64>(n & ~(0x000FFFFF >> k)) << 32);\n        n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n        if (j < 0) n = -n;\n        p_h -= t;\n      }\n      t = p_l + p_h;\n      t = reinterpret<f64>(reinterpret<u64>(t) & 0xFFFFFFFF00000000);\n      u = t * lg2_h;\n      v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n      z = u + v;\n      w = v - (z - u);\n      t = z * z;\n      t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n      r = (z * t1) / (t1 - 2.0) - (w + z * w);\n      z = 1.0 - (r - z);\n      j = <u32>(reinterpret<u64>(z) >> 32);\n      j += n << 20;\n      if ((j >> 20) <= 0) z = scalbn(z, n);\n      else z = reinterpret<f64>(reinterpret<u64>(z) & 0xFFFFFFFF | (<u64>j << 32));\n      return s * z;\n    }\n  }\n\n  export function seedRandom(value: i64): void {\n    random_seeded = true;\n    random_state0_64 = murmurHash3(value);\n    random_state1_64 = murmurHash3(~random_state0_64);\n    random_state0_32 = splitMix32(<u32>value);\n    random_state1_32 = splitMix32(random_state0_32);\n    assert(\n      random_state0_64 != 0 && random_state1_64 != 0 &&\n      random_state0_32 != 0 && random_state1_32 != 0\n    );\n  }\n\n  export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n    if (!random_seeded) seedRandom(reinterpret<i64>(seed()));\n    var s1 = random_state0_64;\n    var s0 = random_state1_64;\n    random_state0_64 = s0;\n    s1 ^= s1 << 23;\n    s1 ^= s1 >> 17;\n    s1 ^= s0;\n    s1 ^= s0 >> 26;\n    random_state1_64 = s1;\n    var r = (s0 >> 12) | 0x3FF0000000000000;\n    return reinterpret<f64>(r) - 1;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function round(x: f64): f64 {\n    let roundUp = builtin_ceil<f64>(x);\n    return select<f64>(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sign(x: f64): f64 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return builtin_abs(x) > 0 ? builtin_copysign<f64>(1, x) : x;\n    } else {\n      return x > 0 ? 1 : x < 0 ? -1 : x;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function signbit(x: f64): bool {\n    return <bool>(reinterpret<u64>(x) >>> 63);\n  }\n\n  export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n    var u  = reinterpret<u64>(x);\n    var ix = <u32>(u >> 32);\n    var sign = ix >> 31;\n\n    ix &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ix <= 0x3FE921FB) {\n      if (ix < 0x3E500000) { // |x| < 2**-26\n        return x;\n      }\n      return sin_kern(x, 0.0, 0);\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7FF00000) return x - x;\n\n    // argument reduction needed\n    var n  = rempio2(x, u, sign);\n    var y0 = rempio2_y0;\n    var y1 = rempio2_y1;\n\n    x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n    return n & 2 ? -x : x;\n  }\n\n  export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n    var u = reinterpret<u64>(x) & 0x7FFFFFFFFFFFFFFF;\n    var a = reinterpret<f64>(u);\n    var w = <u32>(u >> 32);\n    var h = builtin_copysign(0.5, x);\n    if (w < 0x40862E42) {\n      let t = expm1(a);\n      if (w < 0x3FF00000) {\n        if (w < 0x3FF00000 - (26 << 20)) return x;\n        return h * (2 * t - t * t / (t + 1));\n      }\n      return h * (t + t / (t + 1));\n    }\n    return expo2(a, 2 * h);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sqrt(x: f64): f64 {\n    return builtin_sqrt<f64>(x);\n  }\n\n  export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n    var u = reinterpret<u64>(x);\n    var ix = <i32>(u >> 32);\n    var sign = ix >>> 31;\n\n    ix &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ix <= 0x3FE921FB) {\n      if (ix < 0x3E400000) { // |x| < 2**-27\n        return x;\n      }\n      return tan_kern(x, 0.0, 1);\n    }\n\n    // tan(Inf or NaN) is NaN\n    if (ix >= 0x7FF00000) return x - x;\n\n    var n = rempio2(x, u, sign);\n    return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n  }\n\n  export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n    var u = reinterpret<u64>(x);\n    u &= 0x7FFFFFFFFFFFFFFF;\n    var y = reinterpret<f64>(u);\n    var w = <u32>(u >> 32);\n    var t: f64;\n    if (w > 0x3FE193EA) {\n      if (w > 0x40340000) {\n        t = 1 - 0 / y;\n      } else {\n        t = expm1(2 * y);\n        t = 1 - 2 / (t + 2);\n      }\n    } else if (w > 0x3FD058AE) {\n      t = expm1(2 * y);\n      t = t / (t + 2);\n    } else if (w >= 0x00100000) {\n      t = expm1(-2 * y);\n      t = -t / (t + 2);\n    } else t = y;\n    return builtin_copysign<f64>(t, x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function trunc(x: f64): f64 {\n    return builtin_trunc<f64>(x);\n  }\n\n  export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n    const\n      Ox1p53    = reinterpret<f64>(0x4340000000000000),\n      Ox1p1023  = reinterpret<f64>(0x7FE0000000000000),\n      Ox1p_1022 = reinterpret<f64>(0x0010000000000000);\n\n    var y = x;\n    if (n > 1023) {\n      y *= Ox1p1023;\n      n -= 1023;\n      if (n > 1023) {\n        y *= Ox1p1023;\n        n = builtin_min<i32>(n - 1023, 1023);\n      }\n    } else if (n < -1022) {\n      // make sure final n < -53 to avoid double\n      // rounding in the subnormal range\n      y *= Ox1p_1022 * Ox1p53;\n      n += 1022 - 53;\n      if (n < -1022) {\n        y *= Ox1p_1022 * Ox1p53;\n        n = builtin_max<i32>(n + 1022 - 53, -1022);\n      }\n    }\n    return y * reinterpret<f64>(<u64>(0x3FF + n) << 52);\n  }\n\n  export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n    if (builtin_abs<f64>(y) == 1.0) {\n      // x % 1, x % -1  ==>  sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n      // TODO: move this rule to compiler's optimization pass.\n      // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n      return builtin_copysign<f64>(x - builtin_trunc<f64>(x), x);\n    }\n    var ux = reinterpret<u64>(x);\n    var uy = reinterpret<u64>(y);\n    var ex = <i64>(ux >> 52 & 0x7FF);\n    var ey = <i64>(uy >> 52 & 0x7FF);\n    var sx = ux >> 63;\n    var uy1 = uy << 1;\n    if (uy1 == 0 || ex == 0x7FF || isNaN<f64>(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    var ux1 = ux << 1;\n    if (ux1 <= uy1) {\n      return x * f64(ux1 != uy1);\n    }\n    if (!ex) {\n      ex -= builtin_clz<i64>(ux << 12);\n      ux <<= 1 - ex;\n    } else {\n      ux &= <u64>-1 >> 12;\n      ux |= 1 << 52;\n    }\n    if (!ey) {\n      ey -= builtin_clz<i64>(uy << 12);\n      uy <<= 1 - ey;\n    } else {\n      uy &= <u64>-1 >> 12;\n      uy |= 1 << 52;\n    }\n    while (ex > ey) {\n      if (ux >= uy) {\n        if (ux == uy) return 0 * x;\n        ux -= uy;\n      }\n      ux <<= 1;\n      --ex;\n    }\n    if (ux >= uy) {\n      if (ux == uy) return 0 * x;\n      ux -= uy;\n    }\n    // for (; !(ux >> 52); ux <<= 1) --ex;\n    var shift = builtin_clz<i64>(ux << 11);\n    ex -= shift;\n    ux <<= shift;\n    if (ex > 0) {\n      ux -= 1 << 52;\n      ux |= ex << 52;\n    } else {\n      ux >>= -ex + 1;\n    }\n    return reinterpret<f64>(ux | (sx << 63));\n  }\n\n  export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n    var ux = reinterpret<u64>(x);\n    var uy = reinterpret<u64>(y);\n    var ex = <i64>(ux >> 52 & 0x7FF);\n    var ey = <i64>(uy >> 52 & 0x7FF);\n    var sx = <i32>(ux >> 63);\n    if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    if (ux << 1 == 0) return x;\n    var uxi = ux;\n    if (!ex) {\n      ex -= builtin_clz<i64>(uxi << 12);\n      uxi <<= 1 - ex;\n    } else {\n      uxi &= <u64>-1 >> 12;\n      uxi |= 1 << 52;\n    }\n    if (!ey) {\n      ey -= builtin_clz<i64>(uy << 12);\n      uy <<= 1 - ey;\n    } else {\n      uy &= <u64>-1 >> 12;\n      uy |= 1 << 52;\n    }\n    var q: u32 = 0;\n    do {\n      if (ex < ey) {\n        if (ex + 1 == ey) break; // goto end\n        return x;\n      }\n      while (ex > ey) {\n        if (uxi >= uy) {\n          uxi -= uy;\n          ++q;\n        }\n        uxi <<= 1;\n        q <<= 1;\n        --ex;\n      }\n      if (uxi >= uy) {\n        uxi -= uy;\n        ++q;\n      }\n      if (uxi == 0) ex = -60;\n      else {\n        let shift = builtin_clz<i64>(uxi << 11);\n        ex -= shift;\n        uxi <<= shift;\n      }\n      break;\n    } while (false);\n    // end:\n    if (ex > 0) {\n      uxi -= 1 << 52;\n      uxi |= ex << 52;\n    } else {\n      uxi >>= -ex + 1;\n    }\n    x = reinterpret<f64>(uxi);\n    y = builtin_abs<f64>(y);\n    var x2 = x + x;\n    if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && <bool>(q & 1))))) {\n      x -= y;\n      // ++q;\n    }\n    return sx ? -x : x;\n  }\n\n  export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n    var u = reinterpret<u64>(x);\n    var ix = <u32>(u >> 32);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3FE921FB) {  // |x| ~<= π/4\n      if (ix < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n        sincos_sin = x;\n        sincos_cos = 1;\n        return;\n      }\n      sincos_sin = sin_kern(x, 0, 0);\n      sincos_cos = cos_kern(x, 0);\n      return;\n    }\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) {\n      let xx = x - x;\n      sincos_sin = xx;\n      sincos_cos = xx;\n      return;\n    }\n    // general argument reduction needed\n    var n = rempio2(x, u, sign);\n    var y0 = rempio2_y0;\n    var y1 = rempio2_y1;\n    var s = sin_kern(y0, y1, 1);\n    var c = cos_kern(y0, y1);\n    var sin = s, cos = c;\n    if (n & 1) {\n      sin =  c;\n      cos = -s;\n    }\n    if (n & 2) {\n      sin = -sin;\n      cos = -cos;\n    }\n    sincos_sin = sin;\n    sincos_cos = cos;\n  }\n}\n\n// @ts-ignore: decorator\n@lazy var rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data<u64>([\n  0xA2F9836E4E441529,\n  0xFC2757D1F534DDC0,\n  0xDB6295993C439041,\n  0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n  const                    // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n    pS0 = reinterpret<f32>(0x3E2AAA75), //  1.6666586697e-01f\n    pS1 = reinterpret<f32>(0xBD2F13BA), // -4.2743422091e-02f\n    pS2 = reinterpret<f32>(0xBC0DD36B), // -8.6563630030e-03f\n    qS1 = reinterpret<f32>(0xBF34E5AE); // -7.0662963390e-01f\n\n  var p = z * (pS0 + z * (pS1 + z * pS2));\n  var q: f32 = 1 + z * qS1;\n  return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n  const                                // see: musl/src/math/__expo2f.c\n    k    = <u32>235,\n    kln2 = reinterpret<f32>(0x4322E3BC); // 0x1.45c778p+7f\n  var scale = reinterpret<f32>(<u32>(0x7F + (k >> 1)) << 23);\n  // in directed rounding correct sign before rounding or overflow is important\n  return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n  const coeff = reinterpret<f64>(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n  var offset = (u >> 23) - 152;\n  var shift  = <u64>(offset & 63);\n  var tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n  var b0 = load<u64>(tblPtr, 0 << 3);\n  var b1 = load<u64>(tblPtr, 1 << 3);\n  var lo: u64;\n\n  if (shift > 32) {\n    let b2 = load<u64>(tblPtr, 2 << 3);\n    lo  = b2 >> (96 - shift);\n    lo |= b1 << (shift - 32);\n  } else {\n    lo = b1 >> (32 - shift);\n  }\n\n  var hi = (b1 >> (64 - shift)) | (b0 << shift);\n  var mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n  var product = mantissa * hi + (mantissa * lo >> 32);\n  var r: i64 = product << 2;\n  var q = <i32>((product >> 62) + (r >>> 63));\n  rempio2f_y = copysign<f64>(coeff, x) * <f64>r;\n  return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n  const\n    pi2hi = reinterpret<f64>(0x3FF921FB50000000), // 1.57079631090164184570\n    pi2lo = reinterpret<f64>(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n    _2_pi = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n  if (u < 0x4DC90FDB) { // π * 0x1p28\n    let q = nearest(x * _2_pi);\n    rempio2f_y = x - q * pi2hi - q * pi2lo;\n    return <i32>q;\n  }\n\n  var q = pio2f_large_quot(x, u);\n  return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n  const\n    S1 = reinterpret<f64>(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n    S2 = reinterpret<f64>(0x3F811110896EFBB2), //  0x111110896efbb2.0p-59\n    S3 = reinterpret<f64>(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n    S4 = reinterpret<f64>(0x3EC6CD878C3B46A7); //  0x16cd878c3b46a7.0p-71\n\n  var z = x * x;\n  var w = z * z;\n  var r = S3 + z * S4;\n  var s = z * x;\n  return <f32>((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n  const\n    C0 = reinterpret<f64>(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n    C1 = reinterpret<f64>(0x3FA55553E1053A42), //  0x155553e1053a42.0p-57\n    C2 = reinterpret<f64>(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n    C3 = reinterpret<f64>(0x3EF99342E0EE5069); //  0x199342e0ee5069.0p-68\n\n  var z = x * x;\n  var w = z * z;\n  var r = C2 + z * C3;\n  return <f32>(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n  const\n    T0 = reinterpret<f64>(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n    T1 = reinterpret<f64>(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n    T2 = reinterpret<f64>(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n    T3 = reinterpret<f64>(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n    T4 = reinterpret<f64>(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n    T5 = reinterpret<f64>(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n  var z = x * x;\n  var r = T4 + z * T5;\n  var t = T2 + z * T3;\n  var w = z * z;\n  var s = z * x;\n  var u = T0 + z * T1;\n\n  r = (x + s * u) + (s * w) * (t + w * r);\n  return <f32>(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n  const\n    log2e = reinterpret<f64>(0x3FF71547652B82FE), // 1.44269504088896340736\n    c0 = reinterpret<f64>(0x3FD555554FD9CAEF),    // 0.33333332822728226129\n    c1 = reinterpret<f64>(0x3FC999A7A8AF4132),    // 0.20000167595436263505\n    c2 = reinterpret<f64>(0x3FC2438D79437030),    // 0.14268654271188685375\n    c3 = reinterpret<f64>(0x3FBE2F663B001C97);    // 0.11791075649681414150\n\n  var i = reinterpret<i64>(x);\n  var exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n  x = reinterpret<f64>(i - (exponent << 52));\n  x = (x - 1) / (x + 1);\n  var xx = x * x;\n  var y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n  return (2 * log2e) * y + <f64>exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n  const\n    c0 = reinterpret<f64>(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n    c1 = reinterpret<f64>(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n    c2 = reinterpret<f64>(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n    c3 = reinterpret<f64>(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n    c4 = reinterpret<f64>(0x3F55F0896145A89F), // 1.339086685300950937e-3\n    c5 = reinterpret<f64>(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n  if (x < -1022) return 0;\n  if (x >= 1024) return Infinity;\n\n  var n = nearest(x);\n  x -= n;\n  var xx = x * x;\n  var y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n  return reinterpret<f64>(reinterpret<i64>(y) + (<i64>n << 52));\n}\n\nexport namespace NativeMathf {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const E       = <f32>NativeMath.E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN2     = <f32>NativeMath.LN2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN10    = <f32>NativeMath.LN10;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG2E   = <f32>NativeMath.LOG2E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG10E  = <f32>NativeMath.LOG10E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const PI      = <f32>NativeMath.PI;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT1_2 = <f32>NativeMath.SQRT1_2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT2   = <f32>NativeMath.SQRT2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export var sincos_sin: f32 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export var sincos_cos: f32 = 0;\n\n  // @ts-ignore: decorator\n  @inline\n  export function abs(x: f32): f32 {\n    return builtin_abs<f32>(x);\n  }\n\n  export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f32>(0x3FC90FDA), // 1.5707962513e+00f\n      pio2_lo   = reinterpret<f32>(0x33A22168), // 7.5497894159e-08f\n      Ox1p_120f = reinterpret<f32>(0x03800000); // 0x1p-120f\n\n    var hx = reinterpret<u32>(x);\n    var ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3F800000) {\n      if (ix == 0x3F800000) {\n        if (hx >> 31) return 2 * pio2_hi + Ox1p_120f;\n        return 0;\n      }\n      return 0 / (x - x);\n    }\n    if (ix < 0x3F000000) {\n      if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n      return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n    }\n    var z: f32, w: f32, s: f32;\n    if (hx >> 31) {\n      // z = (1 + x) * 0.5;\n      z = 0.5 + x * 0.5;\n      s = builtin_sqrt<f32>(z);\n      w = Rf(z) * s - pio2_lo;\n      return 2 * (pio2_hi - (s + w));\n    }\n    // z = (1 - x) * 0.5;\n    z = 0.5 - x * 0.5;\n    s = builtin_sqrt<f32>(z);\n    hx = reinterpret<u32>(s);\n    var df = reinterpret<f32>(hx & 0xFFFFF000);\n    var c = (z - df * df) / (s + df);\n    w = Rf(z) * s + c;\n    return 2 * (df + w);\n  }\n\n  export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n    const s = reinterpret<f32>(0x3F317218); // 0.693147180559945309417232121458176568f\n    var u = reinterpret<u32>(x);\n    var a = u & 0x7FFFFFFF;\n    if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n      let xm1 = x - 1;\n      return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n    }\n    if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n      return log(2 * x - 1 / (x + builtin_sqrt<f32>(x * x - 1)));\n    }\n    // x >= 0x1p12 or x <= -2 or NaN\n    return log(x) + s;\n  }\n\n  export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2      = reinterpret<f32>(0x3FC90FDB), // 1.570796326794896558e+00f\n      Ox1p_120f = reinterpret<f32>(0x03800000); // 0x1p-120f\n\n    var sx = x;\n    var hx = reinterpret<u32>(x) & 0x7FFFFFFF;\n    if (hx >= 0x3F800000) {\n      if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n      return 0 / (x - x);\n    }\n    if (hx < 0x3F000000) {\n      if (hx < 0x39800000 && hx >= 0x00800000) return x;\n      return x + x * Rf(x * x);\n    }\n    // var z: f32 = (1 - builtin_abs<f32>(x)) * 0.5;\n    var z: f32 = 0.5 - builtin_abs<f32>(x) * 0.5;\n    var s = builtin_sqrt<f64>(z); // sic\n    x = <f32>(pio2 - 2 * (s + s * Rf(z)));\n    return builtin_copysign(x, sx);\n  }\n\n  export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n    const c = reinterpret<f32>(0x3F317218); // 0.693147180559945309417232121458176568f\n    var u = reinterpret<u32>(x) & 0x7FFFFFFF;\n    var y = reinterpret<f32>(u);\n    if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n    else if (u >= 0x3F800000 + (1 << 23))  y =   log(2 * y + 1 / (builtin_sqrt<f32>(y * y + 1) + y));\n    else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt<f32>(y * y + 1) + 1));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n    const\n      atanhi0   = reinterpret<f32>(0x3EED6338), //  4.6364760399e-01f\n      atanhi1   = reinterpret<f32>(0x3F490FDA), //  7.8539812565e-01f\n      atanhi2   = reinterpret<f32>(0x3F7B985E), //  9.8279368877e-01f\n      atanhi3   = reinterpret<f32>(0x3FC90FDA), //  1.5707962513e+00f\n      atanlo0   = reinterpret<f32>(0x31AC3769), //  5.0121582440e-09f\n      atanlo1   = reinterpret<f32>(0x33222168), //  3.7748947079e-08f\n      atanlo2   = reinterpret<f32>(0x33140FB4), //  3.4473217170e-08f\n      atanlo3   = reinterpret<f32>(0x33A22168), //  7.5497894159e-08f\n      aT0       = reinterpret<f32>(0x3EAAAAA9), //  3.3333328366e-01f\n      aT1       = reinterpret<f32>(0xBE4CCA98), // -1.9999158382e-01f\n      aT2       = reinterpret<f32>(0x3E11F50D), //  1.4253635705e-01f\n      aT3       = reinterpret<f32>(0xBDDA1247), // -1.0648017377e-01f\n      aT4       = reinterpret<f32>(0x3D7CAC25), //  6.1687607318e-02f\n      Ox1p_120f = reinterpret<f32>(0x03800000); //  0x1p-120f\n\n    var ix = reinterpret<u32>(x);\n    var sx = x;\n    ix &= 0x7FFFFFFF;\n    var z: f32;\n    if (ix >= 0x4C800000) {\n      if (isNaN(x)) return x;\n      z = atanhi3 + Ox1p_120f;\n      return builtin_copysign(z, sx);\n    }\n    var id: i32;\n    if (ix < 0x3EE00000) {\n      if (ix < 0x39800000) return x;\n      id = -1;\n    } else {\n      x = builtin_abs<f32>(x);\n      if (ix < 0x3F980000) {\n        if (ix < 0x3F300000) {\n          id = 0;\n          x = (2.0 * x - 1.0) / (2.0 + x);\n        } else {\n          id = 1;\n          x = (x - 1.0) / (x + 1.0);\n        }\n      } else {\n        if (ix < 0x401C0000) {\n          id = 2;\n          x = (x - 1.5) / (1.0 + 1.5 * x);\n        } else {\n          id = 3;\n          x = -1.0 / x;\n        }\n      }\n    }\n    z = x * x;\n    var w = z * z;\n    var s1 = z * (aT0 + w * (aT2 + w * aT4));\n    var s2 = w * (aT1 + w * aT3);\n    var s3 = x * (s1 + s2);\n    if (id < 0) return x - s3;\n    switch (id) {\n      case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n      case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n      case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n      case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n      default: unreachable();\n    }\n    return builtin_copysign(z, sx);\n  }\n\n  export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n    var u = reinterpret<u32>(x);\n    var y = builtin_abs(x);\n    if (u < 0x3F800000 - (1 << 23)) {\n      if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n    } else y = 0.5 * log1p(2 * (y / (1 - y)));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n    const\n      pi    = reinterpret<f32>(0x40490FDB), //  3.1415927410e+00f\n      pi_lo = reinterpret<f32>(0xB3BBBD2E); // -8.7422776573e-08f\n\n    if (isNaN(x) || isNaN(y)) return x + y;\n    var ix = reinterpret<u32>(x);\n    var iy = reinterpret<u32>(y);\n    if (ix == 0x3F800000) return atan(y);\n    var m = <u32>(((iy >> 31) & 1) | ((ix >> 30) & 2));\n    ix &= 0x7FFFFFFF;\n    iy &= 0x7FFFFFFF;\n    if (iy == 0) {\n      switch (m) {\n        case 0:\n        case 1: return  y;\n        case 2: return  pi;\n        case 3: return -pi;\n      }\n    }\n    if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n    if (ix == 0x7F800000) {\n      if (iy == 0x7F800000) {\n        let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n        return m & 1 ? -t : t;\n      } else {\n        let t: f32 = m & 2 ? pi : 0.0;\n        return m & 1 ? -t : t;\n      }\n    }\n    if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n    var z: f32;\n    if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n    else z = atan(builtin_abs<f32>(y / x));\n    switch (m) {\n      case 0: return  z;\n      case 1: return -z;\n      case 2: return pi - (z - pi_lo);\n      case 3: return (z - pi_lo) - pi;\n    }\n    unreachable();\n    return 0;\n  }\n\n  export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n    const\n      B1      = <u32>709958130,\n      B2      = <u32>642849266,\n      Ox1p24f = reinterpret<f32>(0x4B800000);\n\n    var u = reinterpret<u32>(x);\n    var hx = u & 0x7FFFFFFF;\n    if (hx >= 0x7F800000) return x + x;\n    if (hx < 0x00800000) {\n      if (hx == 0) return x;\n      u = reinterpret<u32>(x * Ox1p24f);\n      hx = u & 0x7FFFFFFF;\n      hx = hx / 3 + B2;\n    } else {\n      hx = hx / 3 + B1;\n    }\n    u &= 0x80000000;\n    u |= hx;\n    var t = <f64>reinterpret<f32>(u);\n    var r = t * t * t;\n    t = t * (<f64>x + x + r) / (x + r + r);\n    r = t * t * t;\n    t = t * (<f64>x + x + r) / (x + r + r);\n    return <f32>t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function ceil(x: f32): f32 {\n    return builtin_ceil<f32>(x);\n  }\n\n  export function clz32(x: f32): f32 {\n    if (!isFinite(x)) return 32;\n    return <f32>builtin_clz(dtoi32(x));\n  }\n\n  export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n    const\n      c1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // M_PI_2 * 1\n      c2pio2 = reinterpret<f64>(0x400921FB54442D18), // M_PI_2 * 2\n      c3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // M_PI_2 * 3\n      c4pio2 = reinterpret<f64>(0x401921FB54442D18); // M_PI_2 * 4\n\n    var ix = reinterpret<u32>(x);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ix < 0x39800000) { // |x| < 2**-12\n        // raise inexact if x != 0\n        return 1;\n      }\n      return cos_kernf(x);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ix <= 0x407B53D1) {  // |x| ~<= 5π/4\n        if (ix > 0x4016CBE3) { // |x|  ~> 3π/4\n          return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n        } else {\n          return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n        }\n      }\n      if (ix <= 0x40E231D5) {  // |x| ~<= 9π/4\n        if (ix > 0x40AFEDDF) { // |x|  ~> 7π/4\n          return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n        } else {\n          return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n        }\n      }\n    }\n\n    // cos(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) return x - x;\n\n    // general argument reduction needed\n    var n = rempio2f(x, ix, sign);\n    var y = rempio2f_y;\n\n    var t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n    return (n + 1) & 2 ? -t : t;\n  }\n\n  export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n    var u = reinterpret<u32>(x);\n    u &= 0x7FFFFFFF;\n    x = reinterpret<f32>(u);\n    if (u < 0x3F317217) {\n      if (u < 0x3F800000 - (12 << 23)) return 1;\n      let t = expm1(x);\n      // return 1 + t * t / (2 * (1 + t));\n      return 1 + t * t / (2 + 2 * t);\n    }\n    if (u < 0x42B17217) {\n      let t = exp(x);\n      // return 0.5 * (t + 1 / t);\n      return 0.5 * t + 0.5 / t;\n    }\n    return expo2f(x, 1);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function floor(x: f32): f32 {\n    return builtin_floor<f32>(x);\n  }\n\n  export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return expf_lut(x);\n    } else {\n      const\n        ln2hi    = reinterpret<f32>(0x3F317200), //  6.9314575195e-1f\n        ln2lo    = reinterpret<f32>(0x35BFBE8E), //  1.4286067653e-6f\n        invln2   = reinterpret<f32>(0x3FB8AA3B), //  1.4426950216e+0f\n        P1       = reinterpret<f32>(0x3E2AAA8F), //  1.6666625440e-1f\n        P2       = reinterpret<f32>(0xBB355215), // -2.7667332906e-3f\n        Ox1p127f = reinterpret<f32>(0x7F000000); //  0x1p+127f\n\n      let hx = reinterpret<u32>(x);\n      let sign_ = <i32>(hx >> 31);\n      hx &= 0x7FFFFFFF;\n      if (hx >= 0x42AEAC50) {\n        if (hx > 0x7F800000) return x; // NaN\n        if (hx >= 0x42B17218) {\n          if (!sign_) return x * Ox1p127f;\n          else if (hx >= 0x42CFF1B5) return 0;\n        }\n      }\n      let hi: f32, lo: f32;\n      let k: i32;\n      if (hx > 0x3EB17218) {\n        if (hx > 0x3F851592) {\n          k = <i32>(invln2 * x + builtin_copysign<f32>(0.5, x));\n        } else {\n          k = 1 - (sign_ << 1);\n        }\n        hi = x - <f32>k * ln2hi;\n        lo = <f32>k * ln2lo;\n        x = hi - lo;\n      } else if (hx > 0x39000000) {\n        k = 0;\n        hi = x;\n        lo = 0;\n      } else {\n        return 1 + x;\n      }\n      let xx = x * x;\n      let c = x - xx * (P1 + xx * P2);\n      let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n      return k == 0 ? y : scalbn(y, k);\n    }\n  }\n\n  export function exp2(x: f32): f32 {\n    return exp2f_lut(x);\n  }\n\n  export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi   = reinterpret<f32>(0x3F317180), //  6.9313812256e-01f\n      ln2_lo   = reinterpret<f32>(0x3717F7D1), //  9.0580006145e-06f\n      invln2   = reinterpret<f32>(0x3FB8AA3B), //  1.4426950216e+00f\n      Q1       = reinterpret<f32>(0xBD088868), // -3.3333212137e-02f\n      Q2       = reinterpret<f32>(0x3ACF3010), //  1.5807170421e-03f\n      Ox1p127f = reinterpret<f32>(0x7F000000); //  0x1p+127f\n\n    var u = reinterpret<u32>(x);\n    var hx = u & 0x7FFFFFFF;\n    var sign_ = <i32>(u >> 31);\n    if (hx >= 0x4195B844) {\n      if (hx > 0x7F800000) return x;\n      if (sign_) return -1;\n      if (hx > 0x42B17217) { // x > log(FLT_MAX)\n        x *= Ox1p127f;\n        return x;\n      }\n    }\n    var c: f32 = 0.0, t: f32, k: i32;\n    if (hx > 0x3EB17218) {\n      k = select<i32>(\n        1 - (sign_ << 1),\n        <i32>(invln2 * x + builtin_copysign<f32>(0.5, x)),\n        hx < 0x3F851592\n      );\n      t = <f32>k;\n      let hi = x - t * ln2_hi;\n      let lo = t * ln2_lo;\n      x = hi - lo;\n      c = (hi - x) - lo;\n    } else if (hx < 0x33000000) {\n      return x;\n    } else k = 0;\n    var hfx: f32 = 0.5 * x;\n    var hxs: f32 = x * hfx;\n    var r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n    t  = 3.0 - r1 * hfx;\n    var e = hxs * ((r1 - t) / (6.0 - x * t));\n    if (k == 0) return x - (x * e - hxs);\n    e  = x * (e - c) - c;\n    e -= hxs;\n    if (k == -1) return 0.5 * (x - e) - 0.5;\n    if (k == 1) {\n      if (x < -0.25) return -2.0 * (e - (x + 0.5));\n      return 1.0 + 2.0 * (x - e);\n    }\n    u = (0x7F + k) << 23;\n    var twopk = reinterpret<f32>(u);\n    var y: f32;\n    if (k < 0 || k > 56) {\n      y = x - e + 1.0;\n      if (k == 128) y = y * 2.0 * Ox1p127f;\n      else y = y * twopk;\n      return y - 1.0;\n    }\n    u = (0x7F - k) << 23;\n    y = reinterpret<f32>(u);\n    if (k < 20) y = (1 - y) - e;\n    else y = 1 - (e + y);\n    return (x + y) * twopk;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function fround(x: f32): f32 {\n    return x;\n  }\n\n  export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n    const\n      Ox1p90f  = reinterpret<f32>(0x6C800000),\n      Ox1p_90f = reinterpret<f32>(0x12800000);\n\n    var ux = reinterpret<u32>(x);\n    var uy = reinterpret<u32>(y);\n    ux &= 0x7FFFFFFF;\n    uy &= 0x7FFFFFFF;\n    if (ux < uy) {\n      let ut = ux;\n      ux = uy;\n      uy = ut;\n    }\n    x = reinterpret<f32>(ux);\n    y = reinterpret<f32>(uy);\n    if (uy == 0xFF << 23) return y;\n    if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n    var z: f32 = 1;\n    if (ux >= (0x7F + 60) << 23) {\n      z  = Ox1p90f;\n      x *= Ox1p_90f;\n      y *= Ox1p_90f;\n    } else if (uy < (0x7F - 60) << 23) {\n      z  = Ox1p_90f;\n      x *= Ox1p90f;\n      y *= Ox1p90f;\n    }\n    return z * builtin_sqrt<f32>(<f32>(<f64>x * x + <f64>y * y));\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function imul(x: f32, y: f32): f32 {\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    if (!isFinite(x + y)) return 0;\n    return <f32>(dtoi32(x) * dtoi32(y));\n  }\n\n  export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return logf_lut(x);\n    } else {\n      const\n        ln2_hi  = reinterpret<f32>(0x3F317180), // 6.9313812256e-01f\n        ln2_lo  = reinterpret<f32>(0x3717F7D1), // 9.0580006145e-06f\n        Lg1     = reinterpret<f32>(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n        Lg2     = reinterpret<f32>(0x3ECCCE13), // 0xccce13.0p-25f\n        Lg3     = reinterpret<f32>(0x3E91E9EE), // 0x91e9ee.0p-25f\n        Lg4     = reinterpret<f32>(0x3E789E26), // 0xf89e26.0p-26f\n        Ox1p25f = reinterpret<f32>(0x4C000000);\n\n      let u = reinterpret<u32>(x);\n      let k = 0;\n      if (u < 0x00800000 || <bool>(u >> 31)) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (u >> 31) return (x - x) / 0;\n        k -= 25;\n        x *= Ox1p25f;\n        u = reinterpret<u32>(x);\n      } else if (u >= 0x7F800000) {\n        return x;\n      } else if (u == 0x3F800000) {\n        return 0;\n      }\n      u += 0x3F800000 - 0x3F3504F3;\n      k += <u32>(<i32>u >> 23) - 0x7F;\n      u = (u & 0x007FFFFF) + 0x3F3504F3;\n      x = reinterpret<f32>(u);\n      let f = x - 1.0;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * Lg4);\n      let t2 = z * (Lg1 + w * Lg3);\n      let r = t2 + t1;\n      let hfsq = <f32>0.5 * f * f;\n      let dk = <f32>k;\n      return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n    }\n  }\n\n  export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n    const\n      ivln10hi  = reinterpret<f32>(0x3EDE6000), //  4.3432617188e-01f\n      ivln10lo  = reinterpret<f32>(0xB804EAD9), // -3.1689971365e-05f\n      log10_2hi = reinterpret<f32>(0x3E9A2080), //  3.0102920532e-01f\n      log10_2lo = reinterpret<f32>(0x355427DB), //  7.9034151668e-07f\n      Lg1       = reinterpret<f32>(0x3F2AAAAA), //  0xaaaaaa.0p-24f, 0.66666662693f\n      Lg2       = reinterpret<f32>(0x3ECCCE13), //  0xccce13.0p-25f, 0.40000972152f\n      Lg3       = reinterpret<f32>(0x3E91E9EE), //  0x91e9ee.0p-25f, 0.28498786688f\n      Lg4       = reinterpret<f32>(0x3E789E26), //  0xf89e26.0p-26f, 0.24279078841f\n      Ox1p25f   = reinterpret<f32>(0x4C000000); //  0x1p25f\n\n    var ix = reinterpret<u32>(x);\n    var k = 0;\n    if (ix < 0x00800000 || <bool>(ix >> 31)) {\n      if (ix << 1 == 0) return -1 / (x * x);\n      if (ix >> 31) return (x - x) / 0.0;\n      k -= 25;\n      x *= Ox1p25f;\n      ix = reinterpret<u32>(x);\n    } else if (ix >= 0x7F800000) {\n      return x;\n    } else if (ix == 0x3F800000) {\n      return 0;\n    }\n    ix += 0x3F800000 - 0x3F3504F3;\n    k += <i32>(ix >> 23) - 0x7F;\n    ix = (ix & 0x007FFFFF) + 0x3F3504F3;\n    x = reinterpret<f32>(ix);\n    var f = x - 1.0;\n    var s = f / (2.0 + f);\n    var z = s * s;\n    var w = z * z;\n    var t1 = w * (Lg2 + w * Lg4);\n    var t2 = z * (Lg1 + w * Lg3);\n    var r = t2 + t1;\n    var hfsq: f32 = 0.5 * f * f;\n    var hi = f - hfsq;\n    ix = reinterpret<u32>(hi);\n    ix &= 0xFFFFF000;\n    hi = reinterpret<f32>(ix);\n    var lo = f - hi - hfsq + s * (hfsq + r);\n    var dk = <f32>k;\n    return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n  }\n\n  export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi = reinterpret<f32>(0x3F317180), // 6.9313812256e-01\n      ln2_lo = reinterpret<f32>(0x3717F7D1), // 9.0580006145e-06\n      Lg1    = reinterpret<f32>(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n      Lg2    = reinterpret<f32>(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n      Lg3    = reinterpret<f32>(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n      Lg4    = reinterpret<f32>(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n    var ix = reinterpret<u32>(x);\n    var c: f32 = 0, f: f32 = 0;\n    var k: i32 = 1;\n    if (ix < 0x3ED413D0 || <bool>(ix >> 31)) {\n      if (ix >= 0xBF800000) {\n        if (x == -1) return x / 0.0;\n        return (x - x) / 0.0;\n      }\n      if (ix << 1 < 0x33800000 << 1) return x;\n      if (ix <= 0xBE95F619) {\n        k = 0;\n        c = 0;\n        f = x;\n      }\n    } else if (ix >= 0x7F800000) return x;\n    if (k) {\n      let uf: f32 = 1 + x;\n      let iu = reinterpret<u32>(uf);\n      iu += 0x3F800000 - 0x3F3504F3;\n      k = <i32>(iu >> 23) - 0x7F;\n      if (k < 25) {\n        c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n        c /= uf;\n      } else c = 0;\n      iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n      f = reinterpret<f32>(iu) - 1;\n    }\n    var s = f / (2.0 + f);\n    var z = s * s;\n    var w = z * z;\n    var t1 = w * (Lg2 + w * Lg4);\n    var t2 = z * (Lg1 + w * Lg3);\n    var r = t2 + t1;\n    var hfsq: f32 = 0.5 * f * f;\n    var dk = <f32>k;\n    return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n  }\n\n  export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log2f_lut(x);\n    } else {\n      const\n        ivln2hi = reinterpret<f32>(0x3FB8B000), //  1.4428710938e+00f\n        ivln2lo = reinterpret<f32>(0xB9389AD4), // -1.7605285393e-04\n        Lg1     = reinterpret<f32>(0x3F2AAAAA), //  0xaaaaaa.0p-24f, 0.66666662693f\n        Lg2     = reinterpret<f32>(0x3ECCCE13), //  0xccce13.0p-25f, 0.40000972152f\n        Lg3     = reinterpret<f32>(0x3E91E9EE), //  0x91e9ee.0p-25f, 0.28498786688f\n        Lg4     = reinterpret<f32>(0x3E789E26), //  0xf89e26.0p-26f, 0.24279078841f\n        Ox1p25f = reinterpret<f32>(0x4C000000); //  0x1p25f\n\n      let ix = reinterpret<u32>(x);\n      let k: i32 = 0;\n      if (ix < 0x00800000 || <bool>(ix >> 31)) {\n        if (ix << 1 == 0) return -1 / (x * x);\n        if (ix >> 31) return (x - x) / 0.0;\n        k -= 25;\n        x *= Ox1p25f;\n        ix = reinterpret<u32>(x);\n      } else if (ix >= 0x7F800000) {\n        return x;\n      } else if (ix == 0x3F800000) {\n        return 0;\n      }\n      ix += 0x3F800000 - 0x3F3504F3;\n      k += <i32>(ix >> 23) - 0x7F;\n      ix = (ix & 0x007FFFFF) + 0x3F3504F3;\n      x = reinterpret<f32>(ix);\n      let f = x - 1.0;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * Lg4);\n      let t2 = z * (Lg1 + w * Lg3);\n      let r = t2 + t1;\n      let hfsq: f32 = 0.5 * f * f;\n      let hi = f - hfsq;\n      let u = reinterpret<u32>(hi);\n      u &= 0xFFFFF000;\n      hi = reinterpret<f32>(u);\n      let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n      let dk = <f32>k;\n      return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function max(value1: f32, value2: f32): f32 {\n    return builtin_max<f32>(value1, value2);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function min(value1: f32, value2: f32): f32 {\n    return builtin_min<f32>(value1, value2);\n  }\n\n  export function pow(x: f32, y: f32): f32 {\n    // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n    if (builtin_abs<f32>(y) <= 2) {\n      if (y == 2.0) return x * x;\n      if (y == 0.5) {\n        return select<f32>(\n          builtin_abs<f32>(builtin_sqrt<f32>(x)),\n          Infinity,\n          x != -Infinity\n        );\n      }\n      if (y == -1.0) return 1 / x;\n      if (y == 1.0) return x;\n      if (y == 0.0) return 1.0;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      // see: musl/src/math/powf.c\n      return powf_lut(x, y);\n    } else {\n      // based on:  jdh8/metallic/src/math/float/powf.c\n      if (y == 0) return 1;\n      // @ts-ignore: cast\n      if (isNaN(x) | isNaN(y)) {\n        return NaN;\n      }\n      let sign: u32 = 0;\n      let uy = reinterpret<u32>(y);\n      let ux = reinterpret<u32>(x);\n      let sx = ux >> 31;\n      ux &= 0x7FFFFFFF;\n      if (sx && nearest(y) == y) {\n        x = -x;\n        sx = 0;\n        sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n      }\n      let m: u32;\n      if (ux == 0x3F800000) { // x == 1\n        m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n      } else if (ux == 0) {\n        m = uy >> 31 ? 0x7F800000 : 0;\n      } else if (ux == 0x7F800000) {\n        m = uy >> 31 ? 0 : 0x7F800000;\n      } else if (sx) {\n        m = 0x7FC00000;\n      } else {\n        m = reinterpret<u32>(<f32>exp2f(<f64>y * log2f(x)));\n      }\n      return reinterpret<f32>(m | sign);\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function seedRandom(value: i64): void {\n    NativeMath.seedRandom(value);\n  }\n\n  // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n  export function random(): f32 {\n    if (!random_seeded) seedRandom(reinterpret<i64>(seed()));\n\n    var s0 = random_state0_32;\n    var s1 = random_state1_32;\n    var r  = rotl<u32>(s0 * 0x9E3779BB, 5) * 5;\n\n    s1 ^= s0;\n    random_state0_32 = rotl<u32>(s0, 26) ^ s1 ^ (s1 << 9);\n    random_state1_32 = rotl<u32>(s1, 13);\n\n    return reinterpret<f32>((r >> 9) | (127 << 23)) - 1.0;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function round(x: f32): f32 {\n    let roundUp = builtin_ceil<f32>(x);\n    return select<f32>(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sign(x: f32): f32 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return builtin_abs(x) > 0 ? builtin_copysign<f32>(1, x) : x;\n    } else {\n      return x > 0 ? 1 : x < 0 ? -1 : x;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function signbit(x: f32): bool {\n    return <bool>(reinterpret<u32>(x) >>> 31);\n  }\n\n  export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n    const\n      s1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // M_PI_2 * 1\n      s2pio2 = reinterpret<f64>(0x400921FB54442D18), // M_PI_2 * 2\n      s3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // M_PI_2 * 3\n      s4pio2 = reinterpret<f64>(0x401921FB54442D18); // M_PI_2 * 4\n\n    var ix = reinterpret<u32>(x);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ix < 0x39800000) { // |x| < 2**-12\n        return x;\n      }\n      return sin_kernf(x);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ix <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ix <= 0x4016CBE3) { // |x| ~<= 3π/4\n          return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n        }\n        return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n      }\n\n      if (ix <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ix <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n        }\n        return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n      }\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) return x - x;\n\n    var n = rempio2f(x, ix, sign);\n    var y = rempio2f_y;\n\n    var t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n    return n & 2 ? -t : t;\n  }\n\n  export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n    var u = reinterpret<u32>(x) & 0x7FFFFFFF;\n    var a = reinterpret<f32>(u);\n    var h = builtin_copysign<f32>(0.5, x);\n    if (u < 0x42B17217) {\n      let t = expm1(a);\n      if (u < 0x3F800000) {\n        if (u < 0x3F800000 - (12 << 23)) return x;\n        return h * (2 * t - t * t / (t + 1));\n      }\n      return h * (t + t / (t + 1));\n    }\n    return expo2f(a, 2 * h);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sqrt(x: f32): f32 {\n    return builtin_sqrt<f32>(x);\n  }\n\n  export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n    const\n      t1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // 1 * M_PI_2\n      t2pio2 = reinterpret<f64>(0x400921FB54442D18), // 2 * M_PI_2\n      t3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // 3 * M_PI_2\n      t4pio2 = reinterpret<f64>(0x401921FB54442D18); // 4 * M_PI_2\n\n    var ix = reinterpret<u32>(x);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ix < 0x39800000) { // |x| < 2**-12\n        return x;\n      }\n      return tan_kernf(x, 0);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ix <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ix <= 0x4016CBE3) { // |x| ~<= 3π/4\n          return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n        } else {\n          return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n        }\n      }\n      if (ix <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ix <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n        } else {\n          return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n        }\n      }\n    }\n\n    // tan(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) return x - x;\n\n    // argument reduction\n    var n = rempio2f(x, ix, sign);\n    var y = rempio2f_y;\n    return tan_kernf(y, n & 1);\n  }\n\n  export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n    var u = reinterpret<u32>(x);\n    u &= 0x7FFFFFFF;\n    var y = reinterpret<f32>(u);\n    var t: f32;\n    if (u > 0x3F0C9F54) {\n      if (u > 0x41200000) t = 1 + 0 / y;\n      else {\n        t = expm1(2 * y);\n        t = 1 - 2 / (t + 2);\n      }\n    } else if (u > 0x3E82C578) {\n      t = expm1(2 * y);\n      t = t / (t + 2);\n    } else if (u >= 0x00800000) {\n      t = expm1(-2 * y);\n      t = -t / (t + 2);\n    } else t = y;\n    return builtin_copysign<f32>(t, x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function trunc(x: f32): f32 {\n    return builtin_trunc<f32>(x);\n  }\n\n  export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n    const\n      Ox1p24f   = reinterpret<f32>(0x4B800000),\n      Ox1p127f  = reinterpret<f32>(0x7F000000),\n      Ox1p_126f = reinterpret<f32>(0x00800000);\n\n    var y = x;\n    if (n > 127) {\n      y *= Ox1p127f;\n      n -= 127;\n      if (n > 127) {\n        y *= Ox1p127f;\n        n = builtin_min<i32>(n - 127, 127);\n      }\n    } else if (n < -126) {\n      y *= Ox1p_126f * Ox1p24f;\n      n += 126 - 24;\n      if (n < -126) {\n        y *= Ox1p_126f * Ox1p24f;\n        n = builtin_max<i32>(n + 126 - 24, -126);\n      }\n    }\n    return y * reinterpret<f32>(<u32>(0x7F + n) << 23);\n  }\n\n  export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n    if (builtin_abs<f32>(y) == 1.0) {\n      // x % 1, x % -1  ==>  sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n      // TODO: move this rule to compiler's optimization pass.\n      // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n      return builtin_copysign<f32>(x - builtin_trunc<f32>(x), x);\n    }\n    var ux = reinterpret<u32>(x);\n    var uy = reinterpret<u32>(y);\n    var ex = <i32>(ux >> 23 & 0xFF);\n    var ey = <i32>(uy >> 23 & 0xFF);\n    var sm = ux & 0x80000000;\n    var uy1 = uy << 1;\n    if (uy1 == 0 || ex == 0xFF || isNaN<f32>(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    var ux1 = ux << 1;\n    if (ux1 <= uy1) {\n      return x * f32(ux1 != uy1);\n    }\n    if (!ex) {\n      ex -= builtin_clz<u32>(ux << 9);\n      ux <<= 1 - ex;\n    } else {\n      ux &= <u32>-1 >> 9;\n      ux |= 1 << 23;\n    }\n    if (!ey) {\n      ey -= builtin_clz<u32>(uy << 9);\n      uy <<= 1 - ey;\n    } else {\n      uy &= <u32>-1 >> 9;\n      uy |= 1 << 23;\n    }\n    while (ex > ey) {\n      if (ux >= uy) {\n        if (ux == uy) return 0 * x;\n        ux -= uy;\n      }\n      ux <<= 1;\n      --ex;\n    }\n    if (ux >= uy) {\n      if (ux == uy) return 0 * x;\n      ux -= uy;\n    }\n    // for (; !(ux >> 23); ux <<= 1) --ex;\n    var shift = <i32>builtin_clz<u32>(ux << 8);\n    ex -= shift;\n    ux <<= shift;\n    if (ex > 0) {\n      ux -= 1 << 23;\n      ux |= <u32>ex << 23;\n    } else {\n      ux >>= -ex + 1;\n    }\n    return reinterpret<f32>(ux | sm);\n  }\n\n  export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n    var ux = reinterpret<u32>(x);\n    var uy = reinterpret<u32>(y);\n    var ex = <i32>(ux >> 23 & 0xFF);\n    var ey = <i32>(uy >> 23 & 0xFF);\n    var sx = <i32>(ux >> 31);\n    var uxi = ux;\n    if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n    if (ux << 1 == 0) return x;\n    if (!ex) {\n      ex -= builtin_clz<u32>(uxi << 9);\n      uxi <<= 1 - ex;\n    } else {\n      uxi &= <u32>-1 >> 9;\n      uxi |= 1 << 23;\n    }\n    if (!ey) {\n      ey -= builtin_clz<u32>(uy << 9);\n      uy <<= 1 - ey;\n    } else {\n      uy &= <u32>-1 >> 9;\n      uy |= 1 << 23;\n    }\n    var q = 0;\n    do {\n      if (ex < ey) {\n        if (ex + 1 == ey) break; // goto end\n        return x;\n      }\n      while (ex > ey) {\n        if (uxi >= uy) {\n          uxi -= uy;\n          ++q;\n        }\n        uxi <<= 1;\n        q <<= 1;\n        --ex;\n      }\n      if (uxi >= uy) {\n        uxi -= uy;\n        ++q;\n      }\n      if (uxi == 0) ex = -30;\n      else {\n        let shift = builtin_clz<i32>(uxi << 8);\n        ex -= shift;\n        uxi <<= shift;\n      }\n      break;\n    } while (false);\n    // end:\n    if (ex > 0) {\n      uxi -= 1 << 23;\n      uxi |= <u32>ex << 23;\n    } else {\n      uxi >>= -ex + 1;\n    }\n    x = reinterpret<f32>(uxi);\n    y = builtin_abs<f32>(y);\n    var x2 = x + x;\n    if (ex == ey || (ex + 1 == ey && (<f32>x2 > y || (<f32>x2 == y && <bool>(q & 1))))) {\n      x -= y;\n      // q++;\n    }\n    return sx ? -x : x;\n  }\n\n  export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n    const\n      s1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // 1 * M_PI_2\n      s2pio2 = reinterpret<f64>(0x400921FB54442D18), // 2 * M_PI_2\n      s3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // 3 * M_PI_2\n      s4pio2 = reinterpret<f64>(0x401921FB54442D18); // 4 * M_PI_2\n\n    var ix = reinterpret<u32>(x);\n    var sign = ix >> 31;\n    ix &= 0x7FFFFFFF;\n\n    if (ix <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ix < 0x39800000) { // |x| < 2**-12\n        sincos_sin = x;\n        sincos_cos = 1;\n        return;\n      }\n      sincos_sin = sin_kernf(x);\n      sincos_cos = cos_kernf(x);\n      return;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ix <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ix <= 0x4016CBE3) { // |x| ~<= 3π/4\n          if (sign) {\n            sincos_sin = -cos_kernf(x + s1pio2);\n            sincos_cos =  sin_kernf(x + s1pio2);\n          } else {\n            sincos_sin = cos_kernf(s1pio2 - x);\n            sincos_cos = sin_kernf(s1pio2 - x);\n          }\n          return;\n        }\n        // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n        sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n        sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n        return;\n      }\n      if (ix <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ix <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          if (sign) {\n            sincos_sin =  cos_kernf(x + s3pio2);\n            sincos_cos = -sin_kernf(x + s3pio2);\n          } else {\n            sincos_sin = -cos_kernf(x - s3pio2);\n            sincos_cos =  sin_kernf(x - s3pio2);\n          }\n          return;\n        }\n        sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n        sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n        return;\n      }\n    }\n    // sin(Inf or NaN) is NaN\n    if (ix >= 0x7F800000) {\n      let xx = x - x;\n      sincos_sin = xx;\n      sincos_cos = xx;\n      return;\n    }\n    // general argument reduction needed\n    var n = rempio2f(x, ix, sign);\n    var y = rempio2f_y;\n    var s = sin_kernf(y);\n    var c = cos_kernf(y);\n    var sin = s, cos = c;\n    if (n & 1) {\n      sin =  c;\n      cos = -s;\n    }\n    if (n & 2) {\n      sin = -sin;\n      cos = -cos;\n    }\n    sincos_sin = sin;\n    sincos_cos = cos;\n  }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n  var out = 1;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (x == 2) {\n      return select<i32>(1 << e, 0, <u32>e < 32);\n    }\n    if (e <= 0) {\n      if (x == -1) return select<i32>(-1, 1, e & 1);\n      return i32(e == 0) | i32(x == 1);\n    }\n    else if (e == 1) return x;\n    else if (e == 2) return x * x;\n    else if (e < 32) {\n      let log = 32 - clz(e);\n      // 32 = 2 ^ 5, so need only five cases.\n      // But some extra cases needs for properly overflowing\n      switch (log) {\n        case 5: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 4: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 3: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 2: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 1: {\n          if (e & 1) out *= x;\n        }\n      }\n      return out;\n    }\n  }\n  while (e) {\n    if (e & 1) out *= x;\n    e >>>= 1;\n    x *= x;\n  }\n  return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n  var out: i64 = 1;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (x == 2) {\n      return select<i64>(1 << e, 0, <u64>e < 64);\n    }\n    if (e <= 0) {\n      if (x == -1) return select<i64>(-1, 1, e & 1);\n      return i64(e == 0) | i64(x == 1);\n    }\n    else if (e == 1) return x;\n    else if (e == 2) return x * x;\n    else if (e < 64) {\n      let log = 64 - <i32>clz(e);\n      // 64 = 2 ^ 6, so need only six cases.\n      // But some extra cases needs for properly overflowing\n      switch (log) {\n        case 6: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 5: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 4: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 3: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 2: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 1: {\n          if (e & 1) out *= x;\n        }\n      }\n      return out;\n    }\n  }\n  while (e) {\n    if (e & 1) out *= x;\n    e >>>= 1;\n    x *= x;\n  }\n  return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n  case  1: return x;\n  case  2: return x * x;\n  case  3: return x * x * x;\n  case  4: return (b = x * x) * b;\n  case  5: return (b = x * x) * b * x;\n  case  6: return (b = x * x) * b * b;\n  case  7: return (b = x * x) * b * b * x;\n  case  8: return (d = (b = x * x) * b) * d;\n  case  9: return (c = x * x * x) * c * c;\n  case 10: return (d = (b = x * x) * b) * d * b;\n  case 11: return (d = (b = x * x) * b) * d * b * x;\n  case 12: return (d = (b = x * x) * b) * d * d;\n  case 13: return (d = (b = x * x) * b) * d * d * x;\n  case 14: return (d = (b = x * x) * b) * d * d * b;\n  case 15: return (k = (b = x * x) * b * x) * k * k;\n  case 16: return (h = (d = (b = x * x) * b) * d) * h;\n  case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n  case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n  case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n  case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n  case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n  case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n  case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n  case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n  case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n  case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n  case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n  case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n  case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n  case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n  case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n  case 32:\n  ...\n  case 63:\n}\n*/\n","/// <reference path=\"../rt/index.d.ts\" />\n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<u32>([\n  1,\n  10,\n  100,\n  1000,\n  10000,\n  100000,\n  1000000,\n  10000000,\n  100000000,\n  1000000000\n]);\n\n/*\n  Lookup table for pairwise char codes in range [0-99]\n\n  \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n  \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n  \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n  \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n  \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n  \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n  \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n  \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n  \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n  \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data<u32>([\n  0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n  0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n  0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n  0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n  0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n  0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n  0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n  0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n  0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n  0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n  0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n  0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n  0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n  0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n  0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n  0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n  0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n  0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n  0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n  0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data<i16>([/* eslint-disable indent */\n  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,\n   -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,\n   -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,\n   -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,\n   -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,\n    109,   136,   162,   189,   216,   242,   269,   295,   322,   348,\n    375,   402,   428,   455,   481,   508,   534,   561,   588,   614,\n    641,   667,   694,   720,   747,   774,   800,   827,   853,   880,\n    907,   933,   960,   986,  1013,  1039,  1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data<u64>([\n  0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n  0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n  0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n  0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n  0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n  0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n  0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n  0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n  0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n  0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n  0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n  0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n  0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n  0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n  0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n  0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n  0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n  0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n  0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n  0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n  0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n  0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2<T extends number>(value: T): bool {\n  return popcnt<T>(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n  if (value < 100000) {\n    if (value < 100) {\n      return 1 + u32(value >= 10);\n    } else {\n      return 3 + u32(value >= 10000) + u32(value >= 1000);\n    }\n  } else {\n    if (value < 10000000) {\n      return 6 + u32(value >= 1000000);\n    } else {\n      return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n    }\n  }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n  if (value < 1000000000000000) {\n    if (value < 1000000000000) {\n      return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n    } else {\n      return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n    }\n  } else {\n    if (value < 100000000000000000) {\n      return 16 + u32(value >= 10000000000000000);\n    } else {\n      return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n    }\n  }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n  if (isPowerOf2(base)) {\n    return (63 - <u32>clz(num)) / (31 - <u32>clz(base)) + 1;\n  }\n  var b64 = u64(base), b = b64, e: u32 = 1;\n  while (num >= b) {\n    num /= b;\n    b *= b;\n    e <<= 1;\n  }\n  while (num >= 1) {\n    num /= b64;\n    e++;\n  }\n  return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n  while (num >= 10000) {\n    // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n    let t = num / 10000;\n    let r = num % 10000;\n    num = t;\n\n    let d1 = r / 100;\n    let d2 = r % 100;\n\n    let digits1 = <u64>load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n    let digits2 = <u64>load<u32>(DIGITS + (<usize>d2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n  }\n\n  if (num >= 100) {\n    let t  = num / 100;\n    let d1 = num % 100;\n    num = t;\n    offset -= 2;\n    let digits = load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n    store<u32>(buffer + (offset << 1), digits);\n  }\n\n  if (num >= 10) {\n    offset -= 2;\n    let digits = load<u32>(DIGITS + (<usize>num << alignof<u32>()));\n    store<u32>(buffer + (offset << 1), digits);\n  } else {\n    offset -= 1;\n    let digit = CharCode._0 + num;\n    store<u16>(buffer + (offset << 1), digit);\n  }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n  while (num >= 100000000) {\n    let t = num / 100000000;\n    let r = <usize>(num - t * 100000000);\n    num = t;\n\n    let b = r / 10000;\n    let c = r % 10000;\n\n    let b1 = b / 100;\n    let b2 = b % 100;\n    let c1 = c / 100;\n    let c2 = c % 100;\n\n    let digits1 = <u64>load<u32>(DIGITS + (<usize>c1 << alignof<u32>()));\n    let digits2 = <u64>load<u32>(DIGITS + (<usize>c2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n    digits1 = <u64>load<u32>(DIGITS + (<usize>b1 << alignof<u32>()));\n    digits2 = <u64>load<u32>(DIGITS + (<usize>b2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n  }\n\n  utoa32_dec_lut(buffer, <u32>num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n  const lut = changetype<usize>(HEX_DIGITS);\n  while (offset >= 2) {\n    offset -= 2;\n    store<u32>(\n      buffer + (offset << 1),\n      load<u32>(lut + ((<usize>num & 0xFF) << alignof<u32>()))\n    );\n    num >>= 8;\n  }\n  if (offset & 1) {\n    store<u16>(buffer, load<u16>(lut + (<usize>num << 6)));\n  }\n}\n\nfunction utoa_dec_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n  do {\n    let t = num / 10;\n    let r = <u32>(num % 10);\n    num = changetype<T>(t);\n    offset--;\n    store<u16>(buffer + (offset << 1), CharCode._0 + r);\n  } while (num);\n}\n\nfunction utoa_hex_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n  do {\n    let d = num & 0x0F | CharCode._0;\n    d += select<T>(<T>0x27, <T>0, d > <T>CharCode._9);\n    offset--;\n    store<u16>(buffer + (offset << 1), d);\n    // @ts-ignore: type\n    num >>= 4;\n  } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_dec_simple<u32>(buffer, num, offset);\n  } else {\n    utoa32_dec_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_hex_simple<u32>(buffer, num, offset);\n  } else {\n    utoa_hex_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_dec_simple<u64>(buffer, num, offset);\n  } else {\n    utoa64_dec_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_hex_simple<u64>(buffer, num, offset);\n  } else {\n    utoa_hex_lut(buffer, num, offset);\n  }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n  const lut = changetype<usize>(ANY_DIGITS);\n  var base = u64(radix);\n  if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n    let shift = u64(ctz(radix) & 7);\n    let mask = base - 1;\n    do {\n      offset--;\n      store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num & mask) << 1)));\n      num >>= shift;\n    } while (num);\n  } else {\n    do {\n      offset--;\n      let q = num / base;\n      store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num - q * base) << 1)));\n      num = q;\n    } while (num);\n  }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n  var out: String;\n\n  if (radix == 10) {\n    let decimals = decimalCount32(value);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa32_dec_core(changetype<usize>(out), value, decimals);\n  } else if (radix == 16) {\n    let decimals = (31 - clz(value) >> 2) + 1;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa32_hex_core(changetype<usize>(out), value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n  }\n  return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n\n  var sign = value >>> 31;\n  if (sign) value = -value;\n  var out: String;\n\n  if (radix == 10) {\n    let decimals = decimalCount32(value) + sign;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa32_dec_core(changetype<usize>(out), value, decimals);\n  } else if (radix == 16) {\n    let decimals = (31 - clz(value) >> 2) + 1 + sign;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa32_hex_core(changetype<usize>(out), value, decimals);\n  } else {\n    let val32 = u32(value);\n    let decimals = ulog_base(val32, radix) + sign;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_any_core(changetype<usize>(out), val32, decimals, radix);\n  }\n  if (sign) store<u16>(changetype<usize>(out), CharCode.MINUS);\n  return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n  var out: String;\n\n  if (radix == 10) {\n    if (value <= u32.MAX_VALUE) {\n      let val32    = <u32>value;\n      let decimals = decimalCount32(val32);\n      out = changetype<String>(__new(decimals << 1, idof<String>()));\n      utoa32_dec_core(changetype<usize>(out), val32, decimals);\n    } else {\n      let decimals = decimalCount64High(value);\n      out = changetype<String>(__new(decimals << 1, idof<String>()));\n      utoa64_dec_core(changetype<usize>(out), value, decimals);\n    }\n  } else if (radix == 16) {\n    let decimals = (63 - u32(clz(value)) >> 2) + 1;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_hex_core(changetype<usize>(out), value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n  }\n  return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n\n  var sign = u32(value >>> 63);\n  if (sign) value = -value;\n  var out: String;\n\n  if (radix == 10) {\n    if (<u64>value <= <u64>u32.MAX_VALUE) {\n      let val32    = <u32>value;\n      let decimals = decimalCount32(val32) + sign;\n      out = changetype<String>(__new(decimals << 1, idof<String>()));\n      utoa32_dec_core(changetype<usize>(out), val32, decimals);\n    } else {\n      let decimals = decimalCount64High(value) + sign;\n      out = changetype<String>(__new(decimals << 1, idof<String>()));\n      utoa64_dec_core(changetype<usize>(out), value, decimals);\n    }\n  } else if (radix == 16) {\n    let decimals = (63 - u32(clz(value)) >> 2) + 1 + sign;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_hex_core(changetype<usize>(out), value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix) + sign;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n  }\n  if (sign) store<u16>(changetype<usize>(out), CharCode.MINUS);\n  return out;\n}\n\n// @ts-ignore: decorator\n@lazy var _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// var _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy var _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy var _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy var _frc_plus:  u64 = 0;\n\n// @ts-ignore: decorator\n@lazy var _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy var _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n  var u0 = u & 0xFFFFFFFF;\n  var v0 = v & 0xFFFFFFFF;\n\n  var u1 = u >> 32;\n  var v1 = v >> 32;\n\n  var l = u0 * v0;\n  var t = u1 * v0 + (l >> 32);\n  var w = u0 * v1 + (t & 0xFFFFFFFF);\n\n  w += 0x7FFFFFFF; // rounding\n\n  t >>= 32;\n  w >>= 32;\n\n  return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n  return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32): void {\n  var frc = (f << 1) + 1;\n  var exp = e - 1;\n  var off = <i32>clz<u64>(frc);\n  frc <<= off;\n  exp  -= off;\n\n  var m = 1 + i32(f == 0x0010000000000000);\n\n  _frc_plus  = frc;\n  _frc_minus = ((f << m) - 1) << e - m - exp;\n  _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n  var lastp = buffer + ((len - 1) << 1);\n  var digit = load<u16>(lastp);\n  while (\n    rest < wp_w &&\n    delta - rest >= ten_kappa && (\n      rest + ten_kappa < wp_w ||\n      wp_w - rest > rest + ten_kappa - wp_w\n    )\n  ) {\n    --digit;\n    rest += ten_kappa;\n  }\n  store<u16>(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n  const c = reinterpret<f64>(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n  var dk = (-61 - minExp) * c + 347;\t            // dk must be positive, so can do ceiling in positive\n  var k = <i32>dk;\n  k += i32(k != dk); // conversion with ceil\n\n  var index = (k >> 3) + 1;\n  _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n  _frc_pow = load<u64>(FRC_POWERS + (<usize>index << alignof<u64>()));\n  _exp_pow = load<i16>(EXP_POWERS + (<usize>index << alignof<i16>()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32): i32 {\n\n  // frexp routine\n  var uv  = reinterpret<u64>(value);\n  var exp = i32((uv & 0x7FF0000000000000) >>> 52);\n  var sid = uv & 0x000FFFFFFFFFFFFF;\n  var frc = (u64(exp != 0) << 52) + sid;\n  exp = select<i32>(exp, 1, exp) - (0x3FF + 52);\n\n  normalizedBoundaries(frc, exp);\n  getCachedPower(_exp);\n\n  // normalize\n  var off = <i32>clz<u64>(frc);\n  frc <<= off;\n  exp  -= off;\n\n  var frc_pow = _frc_pow;\n  var exp_pow = _exp_pow;\n\n  var w_frc = umul64f(frc, frc_pow);\n  var w_exp = umul64e(exp, exp_pow);\n\n  var wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n  var wp_exp = umul64e(_exp, exp_pow);\n\n  var wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n  var delta  = wp_frc - wm_frc;\n\n  return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n  var one_exp = -mp_exp;\n  var one_frc = (<u64>1) << one_exp;\n  var mask    = one_frc - 1;\n\n  var wp_w_frc = mp_frc - w_frc;\n\n  var p1 = u32(mp_frc >> one_exp);\n  var p2 = mp_frc & mask;\n\n  var kappa = <i32>decimalCount32(p1);\n  var len = sign;\n\n  while (kappa > 0) {\n    let d: u32;\n    switch (kappa) {\n      case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n      case  9: { d = p1 /  100000000; p1 %=  100000000; break; }\n      case  8: { d = p1 /   10000000; p1 %=   10000000; break; }\n      case  7: { d = p1 /    1000000; p1 %=    1000000; break; }\n      case  6: { d = p1 /     100000; p1 %=     100000; break; }\n      case  5: { d = p1 /      10000; p1 %=      10000; break; }\n      case  4: { d = p1 /       1000; p1 %=       1000; break; }\n      case  3: { d = p1 /        100; p1 %=        100; break; }\n      case  2: { d = p1 /         10; p1 %=         10; break; }\n      case  1: { d = p1;              p1 =           0; break; }\n      default: { d = 0; break; }\n    }\n\n    if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n    --kappa;\n    let tmp = ((<u64>p1) << one_exp) + p2;\n    if (tmp <= delta) {\n      _K += kappa;\n      grisuRound(buffer, len, delta, tmp, <u64>load<u32>(POWERS10 + (<usize>kappa << alignof<u32>())) << one_exp, wp_w_frc);\n      return len;\n    }\n  }\n\n  while (true) {\n    p2    *= 10;\n    delta *= 10;\n\n    let d = p2 >> one_exp;\n    if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n    p2 &= mask;\n    --kappa;\n    if (p2 < delta) {\n      _K += kappa;\n      wp_w_frc *= <u64>load<u32>(POWERS10 + (<usize>-kappa << alignof<u32>()));\n      grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n      return len;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n  var sign = k < 0;\n  if (sign) k = -k;\n  var decimals = decimalCount32(k) + 1;\n  utoa32_dec_core(buffer, k, decimals);\n  store<u16>(buffer, <u16>select<u32>(CharCode.MINUS, CharCode.PLUS, sign));\n  return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n  if (!k) {\n    store<u32>(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n    return length + 2;\n  }\n\n  var kk = length + k;\n  if (length <= kk && kk <= 21) {\n    // 1234e7 -> 12340000000\n    for (let i = length; i < kk; ++i) {\n      store<u16>(buffer + (i << 1), CharCode._0);\n    }\n    store<u32>(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n    return kk + 2;\n  } else if (kk > 0 && kk <= 21) {\n    // 1234e-2 -> 12.34\n    let ptr = buffer + (kk << 1);\n    memory.copy(\n      ptr + 2,\n      ptr,\n      -k << 1\n    );\n    store<u16>(buffer + (kk << 1), CharCode.DOT);\n    return length + 1;\n  } else if (-6 < kk && kk <= 0) {\n    // 1234e-6 -> 0.001234\n    let offset = 2 - kk;\n    memory.copy(\n      buffer + (offset << 1),\n      buffer,\n      length << 1\n    );\n    store<u32>(buffer, CharCode._0 | (CharCode.DOT << 16));\n    for (let i = 2; i < offset; ++i) {\n      store<u16>(buffer + (i << 1), CharCode._0);\n    }\n    return length + offset;\n  } else if (length == 1) {\n    // 1e30\n    store<u16>(buffer, CharCode.e, 2);\n    length = genExponent(buffer + 4, kk - 1);\n    return length + 2;\n  } else {\n    let len = length << 1;\n    memory.copy(\n      buffer + 4,\n      buffer + 2,\n      len - 2\n    );\n    store<u16>(buffer,       CharCode.DOT, 2);\n    store<u16>(buffer + len, CharCode.e,   2);\n    length += genExponent(buffer + len + 4, kk - 1);\n    return length + 2;\n  }\n}\n\nfunction dtoa_core(buffer: usize, value: f64): i32 {\n  var sign = i32(value < 0);\n  if (sign) {\n    value = -value;\n    store<u16>(buffer, CharCode.MINUS);\n  }\n  // assert(value > 0 && value <= 1.7976931348623157e308);\n  var len = grisu2(value, buffer, sign);\n  len = prettify(buffer + (sign << 1), len - sign, _K);\n  return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: f64): String {\n  if (value == 0) return \"0.0\";\n  if (!isFinite(value)) {\n    if (isNaN(value)) return \"NaN\";\n    return select<String>(\"-Infinity\", \"Infinity\", value < 0);\n  }\n  var size = dtoa_core(dtoa_buf, value) << 1;\n  var result = changetype<String>(__new(size, idof<String>()));\n  memory.copy(changetype<usize>(result), dtoa_buf, size);\n  return result;\n}\n\nexport function itoa_buffered<T extends number>(buffer: usize, value: T): u32 {\n  var sign: u32 = 0;\n  if (isSigned<T>()) {\n    sign = u32(value < 0);\n    if (sign) {\n      value = changetype<T>(-value);\n      store<u16>(buffer, CharCode.MINUS);\n    }\n  }\n  if (ASC_SHRINK_LEVEL <= 1) {\n    if (isSigned<T>()) {\n      if (sizeof<T>() <= 4) {\n        if (<u32>value < 10) {\n          store<u16>(buffer + (sign << 1), value | CharCode._0);\n          return 1 + sign;\n        }\n      } else {\n        if (<u64>value < 10) {\n          store<u16>(buffer + (sign << 1), value | CharCode._0);\n          return 1 + sign;\n        }\n      }\n    } else {\n      if (value < 10) {\n        store<u16>(buffer, value | CharCode._0);\n        return 1;\n      }\n    }\n  }\n  var decimals = sign;\n  if (sizeof<T>() <= 4) {\n    decimals += decimalCount32(value);\n    utoa32_dec_core(buffer, value, decimals);\n  } else {\n    if (<u64>value <= <u64>u32.MAX_VALUE) {\n      let val32 = <u32>value;\n      decimals += decimalCount32(val32);\n      utoa32_dec_core(buffer, val32, decimals);\n    } else {\n      decimals += decimalCount64High(value);\n      utoa64_dec_core(buffer, value, decimals);\n    }\n  }\n  return decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: f64): u32 {\n  if (value == 0) {\n    store<u16>(buffer, CharCode._0);\n    store<u16>(buffer, CharCode.DOT, 2);\n    store<u16>(buffer, CharCode._0,  4);\n    return 3;\n  }\n  if (!isFinite(value)) {\n    if (isNaN(value)) {\n      store<u16>(buffer, CharCode.N);\n      store<u16>(buffer, CharCode.a, 2);\n      store<u16>(buffer, CharCode.N, 4);\n      return 3;\n    } else {\n      let sign = value < 0;\n      if (sign) {\n        store<u16>(buffer, CharCode.MINUS); // -\n        buffer += 2;\n      }\n      store<u64>(buffer, 0x690066006E0049, 0); // ifnI\n      store<u64>(buffer, 0x7900740069006E, 8); // ytin\n      return 8 + u32(sign);\n    }\n  }\n  return dtoa_core(buffer, value);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa, itoa_buffered, dtoa_buffered, MAX_DOUBLE_LENGTH } from \"./number\";\nimport { ipow32 } from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data<u8>([\n  18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n  41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n  68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n  93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n  17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n  119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n  16,16,125,16,16,16,\n  16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n  255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n  251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n  255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n  255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n  31,254,225,255,\n  159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n  255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n  1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n  255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n  197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n  94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n  159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n  255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n  207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n  253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n  251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n  0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n  0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n  31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n  255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n  255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n  127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n  7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n  255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n  255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n  255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n  63,\n  0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n  255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n  127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n  255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n  255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n  255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n  128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n  255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n  224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n  0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n  255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n  255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n  255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n  255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,\n  31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n  0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n  255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n  0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n  255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n  255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n  255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n  255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n  255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n  126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n  255,\n  15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n  255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n  252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n  254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n  252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n  0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n  255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n  255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n  127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n  254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n  255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n  0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n  0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n  255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n  0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n  255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n  255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n  127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n  253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n  255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n  255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n  3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n  7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n  255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n  127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n  255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n  255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n  255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n  0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n  0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,\n  0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n  255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n  255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n  255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n  255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n  127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n  223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n  255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n  247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n  255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n  128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n  3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n  132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data<u8>([\n  18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n  24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n  29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n  16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n  16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n  16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n  255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n  0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n  255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n  255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n  191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n  255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n  132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n  255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n  255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n  255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n  255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n  0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n  254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n  255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n  255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n  95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n  253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n  255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n  15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data<u8>([\n  18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n  33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n  43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n  47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n  16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n  66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n  88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n  16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n  0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n  1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n  0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n  0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n  254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n  6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n  190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n  4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n  193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n  3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n  0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n  0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n  0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n  0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n  0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n  0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n  0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n  0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n  15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n  0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n  0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n  255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n  3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n  0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n  0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n  0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n  0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n  255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n  128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n  0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n  2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n  255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n  0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n  0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n  0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n  3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n  3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n  0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n  0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n  0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n  0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n  0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n  231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n  0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data<u8>([\n  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n  16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n  32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n  48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n  64,\n  97,98,99,100,101,102,103,104,105,106,107,108,109,\n  110,111,112,113,114,115,116,117,118,119,120,121,122,\n  91,92,93,94,95,96,\n  97,98,99,100,101,102,103,104,105,106,107,108,109,\n  110,111,112,113,114,115,116,117,118,119,120,121,122,\n  123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data<u8>([\n  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n  16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n  32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n  48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n  64,\n  65,66,67,68,69,70,71,72,73,74,75,76,77,\n  78,79,80,81,82,83,84,85,86,87,88,89,90,\n  91,92,93,94,95,96,\n  65,66,67,68,69,70,71,72,73,74,75,76,77,\n  78,79,80,81,82,83,84,85,86,87,88,89,90,\n  123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<f64>([\n  1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n  1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n  1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n  PERCENT = 0x25,\n  PLUS = 0x2B,\n  MINUS = 0x2D,\n  DOT = 0x2E,\n  _0 = 0x30,\n  _1 = 0x31,\n  _2 = 0x32,\n  _3 = 0x33,\n  _4 = 0x34,\n  _5 = 0x35,\n  _6 = 0x36,\n  _7 = 0x37,\n  _8 = 0x38,\n  _9 = 0x39,\n  A = 0x41,\n  B = 0x42,\n  E = 0x45,\n  I = 0x49,\n  N = 0x4E,\n  O = 0x4F,\n  X = 0x58,\n  Z = 0x5A,\n  a = 0x61,\n  b = 0x62,\n  e = 0x65,\n  n = 0x6E,\n  o = 0x6F,\n  u = 0x75,\n  x = 0x78,\n  z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n  return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n  return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n  return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n  if (c < 0x1680) { // < <LS> (1)\n    // <SP>, <TAB>, <LF>, <VT>, <FF>, <CR> and <NBSP>\n    // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n    // @ts-ignore: cast\n    return ((c | 0x80) == 0xA0) | (c - 0x09 <= 0x0D - 0x09);\n  }\n  if (c - 0x2000 <= 0x200A - 0x2000) return true;\n  switch (c) {\n    case 0x1680: // <LS> (1)\n    case 0x2028: // <LS> (2)\n    case 0x2029: // <PS>\n    case 0x202F: // <NNS>\n    case 0x205F: // <MMSP>\n    case 0x3000: // <IS>\n    case 0xFEFF: return true; // <ZWNBSP>\n  }\n  return false;\n}\n\nexport function isAlpha(c: u32): bool {\n  if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n  if (c < 0x20000) {\n    // @ts-ignore: cast\n    return stagedBinaryLookup(ALPHA_TABLE, c);\n  }\n  return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n  // @ts-ignore: cast\n  return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n  // @ts-ignore: cast\n  return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n  const lookaheadLimit = 30; // max lookahead limit\n  var found = false;\n  var pos = index;\n  var minPos = max(0, pos - lookaheadLimit);\n  while (pos > minPos) {\n    let c = codePointBefore(buffer, pos);\n    if (!isCaseIgnorable(c)) {\n      if (isCased(c)) {\n        found = true;\n      } else {\n        return false;\n      }\n    }\n    pos -= isize(c >= 0x10000) + 1;\n  }\n  if (!found) return false;\n  pos = index + 1;\n  var maxPos = min(pos + lookaheadLimit, len);\n  while (pos < maxPos) {\n    let c = <u32>load<u16>(buffer + (pos << 1));\n    if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n      let c1 = <u32>load<u16>(buffer + (pos << 1), 2);\n      if ((c1 & 0xFC00) == 0xDC00) {\n        c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n      }\n    }\n    if (!isCaseIgnorable(c)) {\n      return !isCased(c);\n    }\n    pos += isize(c >= 0x10000) + 1;\n  }\n  return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n  if (index <= 0) return -1;\n  var c = <u32>load<u16>(buffer + (index - 1 << 1));\n  if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n    let c1 = <u32>load<u16>(buffer + (index - 2 << 1));\n    if ((c1 & 0xFC00) == 0xD800) {\n      return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n    }\n  }\n  return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n  return <bool>((load<u8>(table + (<u32>load<u8>(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n  var ptr1 = changetype<usize>(str1) + (index1 << 1);\n  var ptr2 = changetype<usize>(str2) + (index2 << 1);\n  if (ASC_SHRINK_LEVEL < 2) {\n    if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n      do {\n        if (load<u64>(ptr1) != load<u64>(ptr2)) break;\n        ptr1 += 8;\n        ptr2 += 8;\n        len  -= 4;\n      } while (len >= 4);\n    }\n  }\n  while (len--) {\n    let a = <i32>load<u16>(ptr1);\n    let b = <i32>load<u16>(ptr2);\n    if (a != b) return a - b;\n    ptr1 += 2;\n    ptr2 += 2;\n  }\n  return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    return c | u32(isUpper8(c)) << 5;\n  } else {\n    return <u32>load<u8>(LOWER127 + c);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    return c & ~(u32(isLower8(c)) << 5);\n  } else {\n    return <u32>load<u8>(UPPER127 + c);\n  }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol<T>(str: string, radix: i32 = 0): T {\n  var len = str.length;\n  if (!len) {\n    if (isFloat<T>()) {\n      // @ts-ignore: cast\n      return <T>NaN;\n    } else {\n      // @ts-ignore: cast\n      return <T>0;\n    }\n  }\n\n  var ptr = changetype<usize>(str) /* + HEAD -> offset */;\n  var code = <u32>load<u16>(ptr);\n\n  // trim white spaces\n  while (isSpace(code)) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  // determine sign\n  // @ts-ignore\n  var sign: T = 1;\n  if (code == CharCode.MINUS || code == CharCode.PLUS) {\n    if (!--len) {\n      if (isFloat<T>()) {\n        // @ts-ignore: cast\n        return <T>NaN;\n      } else {\n        // @ts-ignore: cast\n        return <T>0;\n      }\n    }\n    if (code == CharCode.MINUS) {\n      // @ts-ignore: type\n      sign = -1;\n    }\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  // See https://tc39.es/ecma262/#sec-parseint-string-radix\n  if (radix) {\n    if (radix < 2 || radix > 36) {\n      if (isFloat<T>()) {\n        // @ts-ignore: cast\n        return <T>NaN;\n      } else {\n        // @ts-ignore: cast\n        return <T>0;\n      }\n    }\n    // handle case as parseInt(\"0xFF\", 16) by spec\n    if (radix == 16) {\n      if (\n        len > 2 &&\n        code == CharCode._0 &&\n        (<u32>load<u16>(ptr, 2) | 32) == CharCode.x\n      ) {\n        ptr += 4; len -= 2;\n      }\n    }\n  } else {\n    // determine radix by literal prefix\n    if (code == CharCode._0 && len > 2) {\n      switch (<u32>load<u16>(ptr, 2) | 32) {\n        case CharCode.b: {\n          ptr += 4; len -= 2;\n          radix = 2;\n          break;\n        }\n        case CharCode.o: {\n          ptr += 4; len -= 2;\n          radix = 8;\n          break;\n        }\n        case CharCode.x: {\n          ptr += 4; len -= 2;\n          radix = 16;\n          break;\n        }\n      }\n    }\n    if (!radix) radix = 10;\n  }\n\n  // calculate value\n  // @ts-ignore: type\n  var num: T = 0;\n  while (len--) {\n    code = <u32>load<u16>(ptr);\n    if (code - CharCode._0 < 10) {\n      code -= CharCode._0;\n    } else if (code - CharCode.A <= <u32>(CharCode.Z - CharCode.A)) {\n      code -= CharCode.A - 10;\n    } else if (code - CharCode.a <= <u32>(CharCode.z - CharCode.a)) {\n      code -= CharCode.a - 10;\n    }\n    if (code >= <u32>radix) {\n      if (!num) {\n        if (isFloat<T>()) {\n          // @ts-ignore: cast\n          return <T>NaN;\n        } else {\n          // @ts-ignore: cast\n          return <T>0;\n        }\n      }\n      break;\n    }\n    // @ts-ignore: type\n    num = num * radix + code;\n    ptr += 2;\n  }\n  // @ts-ignore: type\n  return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n  var len = str.length;\n  if (!len) return NaN;\n\n  var ptr  = changetype<usize>(str);\n  var code = <u32>load<u16>(ptr);\n\n  var sign = 1.0;\n  // skip white spaces\n  while (len && isSpace(code)) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (!len) return NaN;\n\n  // try parse '-' or '+'\n  if (code == CharCode.MINUS) {\n    if (!--len) return NaN;\n    code = <u32>load<u16>(ptr += 2);\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) return NaN;\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  // try parse Infinity\n  if (len >= 8 && code == CharCode.I) {\n    if (\n      load<u64>(ptr, 0) == 0x690066006E0049 && // ifnI\n      load<u64>(ptr, 8) == 0x7900740069006E    // ytin\n    ) {\n      return Infinity * sign;\n    }\n    return NaN;\n  }\n  // validate next symbol\n  if (code != CharCode.DOT && <u32>(code - CharCode._0) >= 10) {\n    return NaN;\n  }\n  var savedPtr = ptr;\n  // skip zeros\n  while (code == CharCode._0) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (len <= 0) return 0;\n  const capacity = 19; // int(64 * 0.3010)\n  var pointed = false;\n  var consumed = 0;\n  var position = 0;\n  var x: u64 = 0;\n  if (code == CharCode.DOT) {\n    let noDigits = !(savedPtr - ptr);\n    ptr += 2; --len;\n    if (!len && noDigits) return NaN;\n    for (pointed = true; (code = <u32>load<u16>(ptr)) == CharCode._0; --position, ptr += 2) --len;\n    if (len <= 0) return 0;\n    if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n  }\n  for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n    if (digit < 10) {\n      x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n      ++consumed;\n    } else {\n      position = consumed;\n      pointed = true;\n    }\n    if (!--len) break;\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  if (!pointed) position = consumed;\n  return copysign<f64>(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) return select(\"true\", \"false\", load<bool>(dataStart));\n\n  var sepLen = separator.length;\n  var valueLen = 5; // max possible length of element len(\"false\")\n  var estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  var result = changetype<string>(__new(estLen << 1, idof<string>()));\n  var offset = 0;\n  var value: bool;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<bool>(dataStart + i);\n    valueLen = 4 + i32(!value);\n    memory.copy(\n      changetype<usize>(result) + (<usize>offset << 1),\n      changetype<usize>(select(\"true\", \"false\", value)),\n      <usize>valueLen << 1\n    );\n    offset += valueLen;\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<bool>(dataStart + <usize>lastIndex);\n  valueLen = 4 + i32(!value);\n  memory.copy(\n    changetype<usize>(result) + (<usize>offset << 1),\n    changetype<usize>(select(\"true\", \"false\", value)),\n    valueLen << 1\n  );\n  offset += valueLen;\n\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinIntegerArray<T>(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    let value = load<T>(dataStart);\n    if (isSigned<T>()) {\n      if (sizeof<T>() <= 4) {\n        // @ts-ignore: type\n        return changetype<string>(itoa32(<i32>value, 10));\n      } else {\n        // @ts-ignore: type\n        return changetype<string>(itoa64(<i32>value, 10));\n      }\n    } else {\n      if (sizeof<T>() <= 4) {\n        // @ts-ignore: type\n        return changetype<string>(utoa32(<u32>value, 10));\n      } else {\n        // @ts-ignore: type\n        return changetype<string>(utoa64(<u64>value, 10));\n      }\n    }\n  }\n\n  var sepLen = separator.length;\n  const valueLen = (sizeof<T>() <= 4 ? 10 : 20) + i32(isSigned<T>());\n  var estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  var result = changetype<string>(__new(estLen << 1, idof<string>()));\n  var offset = 0;\n  var value: T;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    offset += itoa_buffered<T>(changetype<usize>(result) + (<usize>offset << 1), value);\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  offset += itoa_buffered<T>(changetype<usize>(result) + (<usize>offset << 1), value);\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinFloatArray<T>(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    return changetype<string>(dtoa(\n      // @ts-ignore: type\n      load<T>(dataStart))\n    );\n  }\n\n  const valueLen = MAX_DOUBLE_LENGTH;\n  var sepLen = separator.length;\n  var estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  var result = changetype<string>(__new(estLen << 1, idof<string>()));\n  var offset = 0;\n  var value: T;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    offset += dtoa_buffered(changetype<usize>(result) + (<usize>offset << 1), value);\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  offset += dtoa_buffered(changetype<usize>(result) + (<usize>offset << 1), value);\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    // @ts-ignore: type\n    return load<string>(dataStart) || \"\";\n  }\n  var estLen = 0;\n  var value: string;\n  for (let i = 0; i < length; ++i) {\n    value = load<string>(dataStart + (<usize>i << alignof<string>()));\n    // @ts-ignore: type\n    if (value !== null) estLen += value.length;\n  }\n  var offset = 0;\n  var sepLen = separator.length;\n  var result = changetype<string>(__new((estLen + sepLen * lastIndex) << 1, idof<string>()));\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<string>(dataStart + (<usize>i << alignof<string>()));\n    if (value !== null) {\n      let valueLen = value.length;\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(value),\n        <usize>valueLen << 1\n      );\n      offset += valueLen;\n    }\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<string>(dataStart + (<usize>lastIndex << alignof<string>()));\n  if (value !== null) {\n    memory.copy(\n      changetype<usize>(result) + (<usize>offset << 1),\n      changetype<usize>(value),\n      <usize>value.length << 1\n    );\n  }\n  return result;\n}\n\nexport function joinReferenceArray<T>(dataStart: usize, length: i32, separator: string): string {\n  var lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  var value: T;\n  if (!lastIndex) {\n    value = load<T>(dataStart);\n    // @ts-ignore: type\n    return value !== null ? value.toString() : \"\";\n  }\n  var result = \"\";\n  var sepLen = separator.length;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    if (value !== null) result += value.toString();\n    if (sepLen) result += separator;\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  if (value !== null) result += value.toString();\n  return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n  if (!significand || exp < -342) return 0;\n  if (exp > 308) return Infinity;\n  // Try use fast path\n  // Use fast path for string-to-double conversion if possible\n  // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n  // Simple integer\n  var significandf = <f64>significand;\n  if (!exp) return significandf;\n  if (exp > 22 && exp <= 22 + 15) {\n    significandf *= pow10(exp - 22);\n    exp = 22;\n  }\n  if (significand <= 9007199254740991 && abs(exp) <= 22) {\n    if (exp > 0) return significandf * pow10(exp);\n    return significandf / pow10(-exp);\n  } else if (exp < 0) {\n    return scaledown(significand, exp);\n  } else {\n    return scaleup(significand, exp);\n  }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n  const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n  const scale = reinterpret<f64>(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n  var shift = clz(significand);\n  significand <<= shift;\n  shift = exp - shift;\n\n  for (; exp <= -14; exp += 14) {\n    let q = significand / denom;\n    let r = significand % denom;\n    let s = clz(q);\n    significand = (q << s) + <u64>nearest(scale * <f64>(r << (s - 18)));\n    shift -= s;\n  }\n  var b = <u64>ipow32(5, -exp);\n  var q = significand / b;\n  var r = significand % b;\n  var s = clz(q);\n  significand = (q << s) + <u64>(reinterpret<f64>(reinterpret<u64>(<f64>r) + (s << 52)) / <f64>b);\n  shift -= s;\n\n  return NativeMath.scalbn(<f64>significand, <i32>shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n  const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n  var shift = ctz(significand);\n  significand >>= shift;\n  shift += exp;\n\n  __fixmulShift = shift;\n  for (; exp >= 13; exp -= 13) {\n    significand = fixmul(significand, coeff);\n  }\n  significand = fixmul(significand, <u32>ipow32(5, exp));\n  shift = __fixmulShift;\n  return NativeMath.scalbn(<f64>significand, <i32>shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n  var sign = 1, magnitude = 0;\n  var code = <u32>load<u16>(ptr);\n  // check code is 'e' or 'E'\n  if ((code | 32) != CharCode.e) return 0;\n\n  if (!--len) return 0;\n  code = <u32>load<u16>(ptr += 2);\n  if (code == CharCode.MINUS) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n  }\n  // skip zeros\n  while (code == CharCode._0) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n  }\n  for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n    if (magnitude >= 3200) return sign * 3200;\n    magnitude = 10 * magnitude + digit;\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy var __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n  var low  = (a & 0xFFFFFFFF) * b;\n  var high = (a >> 32) * b + (low >> 32);\n  var overflow = <u32>(high >> 32);\n  var space = clz(overflow);\n  var revspace: u64 = 32 - space;\n  __fixmulShift += revspace;\n  return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n  // argument `n` should bounds in [0, 22] range\n  return load<f64>(POWERS10 + (n << alignof<f64>()));\n}\n","/// <reference path=\"./rt/index.d.ts\" />\n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_ILLEGALGENTYPE, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n  // Depends on the fact that Arrays mimic ArrayBufferView\n  var oldCapacity = <usize>changetype<ArrayBufferView>(array).byteLength;\n  if (newSize > oldCapacity >>> alignLog2) {\n    if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n    let oldData = changetype<usize>(changetype<ArrayBufferView>(array).buffer);\n    // Grows old capacity by factor of two.\n    // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n    let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n    if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n    let newData = __renew(oldData, newCapacity);\n    memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n    if (newData !== oldData) { // oldData has been free'd\n      store<usize>(array, newData, offsetof<ArrayBufferView>(\"buffer\"));\n      store<usize>(array, newData, offsetof<ArrayBufferView>(\"dataStart\"));\n      __link(array, changetype<usize>(newData), false);\n    }\n    store<u32>(array, <u32>newCapacity, offsetof<ArrayBufferView>(\"byteLength\"));\n  }\n}\n\nexport class Array<T> {\n  [key: number]: T;\n\n  // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n  // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n  // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n  // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n  private buffer: ArrayBuffer;\n  @unsafe readonly dataStart: usize;\n  private byteLength: i32; // Uses here as capacity\n\n  // Also note that Array<T> with non-nullable T must guard against uninitialized null values\n  // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n  // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n  private length_: i32;\n\n  static isArray<U>(value: U): bool {\n    return isReference<U>() ? builtin_isArray(value) && value !== null : false;\n  }\n\n  static create<T>(capacity: i32 = 0): Array<T> {\n    WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n    var array = new Array<T>(capacity);\n    array.length = 0;\n    return array;\n  }\n\n  constructor(length: i32 = 0) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new RangeError(E_INVALIDLENGTH);\n    // reserve capacity for at least MIN_SIZE elements\n    var bufferSize = max(<usize>length, MIN_SIZE) << alignof<T>();\n    var buffer = changetype<ArrayBuffer>(__new(bufferSize, idof<ArrayBuffer>()));\n    memory.fill(changetype<usize>(buffer), 0, bufferSize);\n    this.buffer = buffer; // links\n    this.dataStart = changetype<usize>(buffer);\n    this.byteLength = <i32>bufferSize;\n    this.length_ = length;\n  }\n\n  get length(): i32 {\n    return this.length_;\n  }\n\n  set length(newLength: i32) {\n    ensureCapacity(changetype<usize>(this), newLength, alignof<T>(), false);\n    this.length_ = newLength;\n  }\n\n  every(fn: (value: T, index: i32, array: Array<T>) => bool): bool {\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      if (!fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return false;\n    }\n    return true;\n  }\n\n  findIndex(predicate: (value: T, index: i32, array: Array<T>) => bool): i32 {\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      if (predicate(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return index;\n    }\n    return -1;\n  }\n\n  @operator(\"[]\") private __get(index: i32): T {\n    if (<u32>index >= <u32>this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n    var value = load<T>(this.dataStart + (<usize>index << alignof<T>()));\n    if (isReference<T>()) {\n      if (!isNullable<T>()) {\n        if (!changetype<usize>(value)) throw new Error(E_HOLEYARRAY);\n      }\n    }\n    return value;\n  }\n\n  @unsafe @operator(\"{}\") private __uget(index: i32): T {\n    return load<T>(this.dataStart + (<usize>index << alignof<T>()));\n  }\n\n  @operator(\"[]=\") private __set(index: i32, value: T): void {\n    if (<u32>index >= <u32>this.length_) {\n      if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n      ensureCapacity(changetype<usize>(this), index + 1, alignof<T>());\n      this.length_ = index + 1;\n    }\n    this.__uset(index, value);\n  }\n\n  @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n    store<T>(this.dataStart + (<usize>index << alignof<T>()), value);\n    if (isManaged<T>()) {\n      __link(changetype<usize>(this), changetype<usize>(value), true);\n    }\n  }\n\n  at(index: i32): T {\n    var len = this.length_;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    var value = load<T>(this.dataStart + (<usize>index << alignof<T>()));\n    if (isReference<T>()) {\n      if (!isNullable<T>()) {\n        if (!changetype<usize>(value)) throw new Error(E_HOLEYARRAY);\n      }\n    }\n    return value;\n  }\n\n  fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): this {\n    var dataStart = this.dataStart;\n    var length = this.length_;\n    start = start < 0 ? max(length + start, 0) : min(start, length);\n    end   = end   < 0 ? max(length + end,   0) : min(end,   length);\n    if (isManaged<T>()) {\n      for (; start < end; ++start) {\n        store<usize>(dataStart + (<usize>start << alignof<T>()), changetype<usize>(value));\n        __link(changetype<usize>(this), changetype<usize>(value), true);\n      }\n    } else if (sizeof<T>() == 1) {\n      if (start < end) {\n        memory.fill(\n          dataStart + <usize>start,\n          u8(value),\n          <usize>(end - start)\n        );\n      }\n    } else {\n      for (; start < end; ++start) {\n        store<T>(dataStart + (<usize>start << alignof<T>()), value);\n      }\n    }\n    return this;\n  }\n\n  includes(value: T, fromIndex: i32 = 0): bool {\n    if (isFloat<T>()) {\n      let length = this.length_;\n      if (length == 0 || fromIndex >= length) return false;\n      if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n      let dataStart = this.dataStart;\n      while (fromIndex < length) {\n        let elem = load<T>(dataStart + (<usize>fromIndex << alignof<T>()));\n        // @ts-ignore\n        if (elem == value || isNaN(elem) & isNaN(value)) return true;\n        ++fromIndex;\n      }\n      return false;\n    } else {\n      return this.indexOf(value, fromIndex) >= 0;\n    }\n  }\n\n  indexOf(value: T, fromIndex: i32 = 0): i32 {\n    var length = this.length_;\n    if (length == 0 || fromIndex >= length) return -1;\n    if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n    var dataStart = this.dataStart;\n    while (fromIndex < length) {\n      if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;\n      ++fromIndex;\n    }\n    return -1;\n  }\n\n  lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n    var length = this.length_;\n    if (length == 0) return -1;\n    if (fromIndex < 0) fromIndex = length + fromIndex;\n    else if (fromIndex >= length) fromIndex = length - 1;\n    var dataStart = this.dataStart;\n    while (fromIndex >= 0) {\n      if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;\n      --fromIndex;\n    }\n    return -1;\n  }\n\n  push(value: T): i32 {\n    var length = this.length_;\n    var newLength = length + 1;\n    ensureCapacity(changetype<usize>(this), newLength, alignof<T>());\n    if (isManaged<T>()) {\n      store<usize>(this.dataStart + (<usize>length << alignof<T>()), changetype<usize>(value));\n      __link(changetype<usize>(this), changetype<usize>(value), true);\n    } else {\n      store<T>(this.dataStart + (<usize>length << alignof<T>()), value);\n    }\n    this.length_ = newLength;\n    return newLength;\n  }\n\n  concat(other: Array<T>): Array<T> {\n    var thisLen = this.length_;\n    var otherLen = select(0, other.length_, other === null);\n    var outLen = thisLen + otherLen;\n    if (<u32>outLen > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new Error(E_INVALIDLENGTH);\n    var out = changetype<Array<T>>(__newArray(outLen, alignof<T>(), idof<Array<T>>()));\n    var outStart = out.dataStart;\n    var thisSize = <usize>thisLen << alignof<T>();\n    if (isManaged<T>()) {\n      let thisStart = this.dataStart;\n      for (let offset: usize = 0; offset < thisSize; offset += sizeof<T>()) {\n        let ref = load<usize>(thisStart + offset);\n        store<usize>(outStart + offset, ref);\n        __link(changetype<usize>(out), ref, true);\n      }\n      outStart += thisSize;\n      let otherStart = other.dataStart;\n      let otherSize = <usize>otherLen << alignof<T>();\n      for (let offset: usize = 0; offset < otherSize; offset += sizeof<T>()) {\n        let ref = load<usize>(otherStart + offset);\n        store<usize>(outStart + offset, ref);\n        __link(changetype<usize>(out), ref, true);\n      }\n    } else {\n      memory.copy(outStart, this.dataStart, thisSize);\n      memory.copy(outStart + thisSize, other.dataStart, <usize>otherLen << alignof<T>());\n    }\n    return out;\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): this {\n    var dataStart = this.dataStart;\n    var len = this.length_;\n\n    end = min<i32>(end, len);\n\n    var to    = target < 0 ? max(len + target, 0) : min(target, len);\n    var from  = start < 0 ? max(len + start, 0) : min(start, len);\n    var last  = end < 0 ? max(len + end, 0) : min(end, len);\n    var count = min(last - from, len - to);\n\n    memory.copy( // is memmove\n      dataStart + (<usize>to << alignof<T>()),\n      dataStart + (<usize>from << alignof<T>()),\n      <usize>count << alignof<T>()\n    );\n    return this;\n  }\n\n  pop(): T {\n    var length = this.length_;\n    if (length < 1) throw new RangeError(E_EMPTYARRAY);\n    var element = load<T>(this.dataStart + (<usize>(--length) << alignof<T>()));\n    this.length_ = length;\n    return element;\n  }\n\n  forEach(fn: (value: T, index: i32, array: Array<T>) => void): void {\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);\n    }\n  }\n\n  map<U>(fn: (value: T, index: i32, array: Array<T>) => U): Array<U> {\n    var length = this.length_;\n    var out = changetype<Array<U>>(__newArray(length, alignof<U>(), idof<Array<U>>()));\n    var outStart = out.dataStart;\n    for (let index = 0; index < min(length, this.length_); ++index) {\n      let result = fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);\n      store<U>(outStart + (<usize>index << alignof<U>()), result);\n      if (isManaged<U>()) {\n        __link(changetype<usize>(out), changetype<usize>(result), true);\n      }\n    }\n    return out;\n  }\n\n  filter(fn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {\n    var result = changetype<Array<T>>(__newArray(0, alignof<T>(), idof<Array<T>>()));\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      let value = load<T>(this.dataStart + (<usize>index << alignof<T>()));\n      if (fn(value, index, this)) result.push(value);\n    }\n    return result;\n  }\n\n  reduce<U>(\n    fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,\n    initialValue: U\n  ): U {\n    var accum = initialValue;\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      accum = fn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);\n    }\n    return accum;\n  }\n\n  reduceRight<U>(\n    fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,\n    initialValue: U\n  ): U {\n    var accum = initialValue;\n    for (let index = this.length_ - 1; index >= 0; --index) {\n      accum = fn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);\n    }\n    return accum;\n  }\n\n  shift(): T {\n    var length = this.length_;\n    if (length < 1) throw new RangeError(E_EMPTYARRAY);\n    var base = this.dataStart;\n    var element = load<T>(base);\n    var lastIndex = length - 1;\n    memory.copy(\n      base,\n      base + sizeof<T>(),\n      <usize>lastIndex << alignof<T>()\n    );\n    if (isReference<T>()) {\n      store<usize>(base + (<usize>lastIndex << alignof<T>()), 0);\n    } else {\n      // @ts-ignore\n      store<T>(base + (<usize>lastIndex << alignof<T>()), <T>0);\n    }\n    this.length_ = lastIndex;\n    return element;\n  }\n\n  some(fn: (value: T, index: i32, array: Array<T>) => bool): bool {\n    for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {\n      if (fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return true;\n    }\n    return false;\n  }\n\n  unshift(value: T): i32 {\n    var newLength = this.length_ + 1;\n    ensureCapacity(changetype<usize>(this), newLength, alignof<T>());\n    var dataStart = this.dataStart;\n    memory.copy(\n      dataStart + sizeof<T>(),\n      dataStart,\n      <usize>(newLength - 1) << alignof<T>()\n    );\n    store<T>(dataStart, value);\n    if (isManaged<T>()) {\n      __link(changetype<usize>(this), changetype<usize>(value), true);\n    }\n    this.length_ = newLength;\n    return newLength;\n  }\n\n  slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array<T> {\n    var length = this.length_;\n    start = start < 0 ? max(start + length, 0) : min(start, length);\n    end   = end   < 0 ? max(end   + length, 0) : min(end  , length);\n    length = max(end - start, 0);\n    var slice = changetype<Array<T>>(__newArray(length, alignof<T>(), idof<Array<T>>()));\n    var sliceBase = slice.dataStart;\n    var thisBase = this.dataStart + (<usize>start << alignof<T>());\n    if (isManaged<T>()) {\n      let off = <usize>0;\n      let end = <usize>length << alignof<usize>();\n      while (off < end) {\n        let ref = load<usize>(thisBase + off);\n        store<usize>(sliceBase + off, ref);\n        __link(changetype<usize>(slice), ref, true);\n        off += sizeof<usize>();\n      }\n    } else {\n      memory.copy(sliceBase, thisBase, length << alignof<T>());\n    }\n    return slice;\n  }\n\n  splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array<T> {\n    var length  = this.length_;\n    start       = start < 0 ? max<i32>(length + start, 0) : min<i32>(start, length);\n    deleteCount = max<i32>(min<i32>(deleteCount, length - start), 0);\n    var result = changetype<Array<T>>(__newArray(deleteCount, alignof<T>(), idof<Array<T>>()));\n    var resultStart = result.dataStart;\n    var thisStart = this.dataStart;\n    var thisBase  = thisStart + (<usize>start << alignof<T>());\n    memory.copy(\n      resultStart,\n      thisBase,\n      <usize>deleteCount << alignof<T>()\n    );\n    var offset = start + deleteCount;\n    if (length != offset) {\n      memory.copy(\n        thisBase,\n        thisStart + (<usize>offset << alignof<T>()),\n        <usize>(length - offset) << alignof<T>()\n      );\n    }\n    this.length_ = length - deleteCount;\n    return result;\n  }\n\n  reverse(): Array<T> {\n    var length = this.length_;\n    if (length) {\n      let front = this.dataStart;\n      let back = this.dataStart + (<usize>(length - 1) << alignof<T>());\n      while (front < back) {\n        let temp = load<T>(front);\n        store<T>(front, load<T>(back));\n        store<T>(back, temp);\n        front += sizeof<T>();\n        back -= sizeof<T>();\n      }\n    }\n    return this;\n  }\n\n  sort(comparator: (a: T, b: T) => i32 = COMPARATOR<T>()): this {\n    var length = this.length_;\n    if (length <= 1) return this;\n    var base = this.dataStart;\n    if (length == 2) {\n      let a: T = load<T>(base, sizeof<T>()); // a = arr[1]\n      let b: T = load<T>(base); // b = arr[0]\n      if (comparator(a, b) < 0) {\n        store<T>(base, b, sizeof<T>()); // arr[1] = b;\n        store<T>(base, a); // arr[0] = a;\n      }\n      return this;\n    }\n    SORT<T>(base, length, comparator);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    var dataStart = this.dataStart;\n    var length = this.length_;\n    if (isBoolean<T>())   return joinBooleanArray(dataStart, length, separator);\n    if (isInteger<T>())   return joinIntegerArray<T>(dataStart, length, separator);\n    if (isFloat<T>())     return joinFloatArray<T>(dataStart, length, separator);\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (isString<T>())  return joinStringArray(dataStart, length, separator);\n    }\n    // For rest objects and arrays use general join routine\n    if (isReference<T>()) return joinReferenceArray<T>(dataStart, length, separator);\n    ERROR(\"unspported element type\");\n    return <string>unreachable();\n  }\n\n  flat(): T {\n    if (!isArray<T>()) {\n      throw new TypeError(E_ILLEGALGENTYPE);\n    }\n    // Get the length and data start values\n    var length = this.length_;\n    var selfDataStart = this.dataStart;\n\n    // calculate the end size with an initial pass\n    var size = 0;\n    for (let i = 0; i < length; i++) {\n      let child = load<usize>(selfDataStart + (i << alignof<T>()));\n      size += child == 0 ? 0 : load<i32>(child, offsetof<T>(\"length_\"));\n    }\n\n    // calculate the byteLength of the resulting backing ArrayBuffer\n    var byteLength = <usize>size << usize(alignof<valueof<T>>());\n    var outBuffer = changetype<ArrayBuffer>(__new(byteLength, idof<ArrayBuffer>()));\n\n    // create the return value and initialize it\n    var outArray = changetype<T>(__new(offsetof<T>(), idof<T>()));\n    store<i32>(changetype<usize>(outArray), size, offsetof<T>(\"length_\"));\n\n    // byteLength, dataStart, and buffer are all readonly\n    store<i32>(changetype<usize>(outArray), byteLength, offsetof<T>(\"byteLength\"));\n    store<usize>(changetype<usize>(outArray), changetype<usize>(outBuffer), offsetof<T>(\"dataStart\"));\n    store<usize>(changetype<usize>(outArray), changetype<usize>(outBuffer), offsetof<T>(\"buffer\"));\n    __link(changetype<usize>(outArray), changetype<usize>(outBuffer), false);\n\n    // set the elements\n    var resultOffset: usize = 0;\n    for (let i = 0; i < length; i++) { // for each child\n      let child = load<usize>(selfDataStart + (<usize>i << alignof<T>()));\n\n      // ignore null arrays\n      if (child == 0) continue;\n\n      // copy the underlying buffer data to the result buffer\n      let childDataLength = load<i32>(child, offsetof<T>(\"byteLength\"));\n      memory.copy(\n        changetype<usize>(outBuffer) + resultOffset,\n        load<usize>(child, offsetof<T>(\"dataStart\")),\n        <usize>childDataLength\n      );\n\n      // advance the result length\n      resultOffset += childDataLength;\n    }\n\n    // if the `valueof<T>` type is managed, we must link each reference\n    if (isManaged<valueof<T>>()) {\n      for (let i = 0; i < size; i++) {\n        let ref = load<usize>(changetype<usize>(outBuffer) + (<usize>i << usize(alignof<valueof<T>>())));\n        __link(changetype<usize>(outBuffer), ref, true);\n      }\n    }\n\n    return outArray;\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  // RT integration\n\n  @unsafe private __visit(cookie: u32): void {\n    if (isManaged<T>()) {\n      let cur = this.dataStart;\n      let end = cur + (<usize>this.length_ << alignof<T>());\n      while (cur < end) {\n        let val = load<usize>(cur);\n        if (val) __visit(val, cookie);\n        cur += sizeof<usize>();\n      }\n    }\n    __visit(changetype<usize>(this.buffer), cookie);\n  }\n}\n","import SomaSolver from \"./SomaSolver\";\nimport VoxelSpace from \"./VoxelSpace\";\n\n\nexport function solve(polycubes: Array<i64>, dimX: i32, dimY: i32, dimZ: i32): Int64Array[] {\n    const solver = new SomaSolver(dimX, dimY, dimZ);\n    const voxelSpaces = new Array<VoxelSpace>();\n    for (let i = 0; i < polycubes.length; i++) {\n        voxelSpaces.push(new VoxelSpace(i, dimX, dimY, dimZ, polycubes[i], true));\n    }\n    solver.solve(voxelSpaces);\n    const solutions = solver.getSolutions();\n    let output: Int64Array[] = new Array<Int64Array>();\n    for (let i = 0; i < solutions.length; i++) {\n        const pieces = solutions[i].getPieces();\n        output.push(new Int64Array(pieces.length));\n        for (let j = 0; j < pieces.length; j++) {\n            output[i][j] = pieces[j].getRaw();\n        }\n    }\n    return output;\n}","import VoxelSpace from \"./VoxelSpace\";\n\nexport default class SomaSolution {\n    private solutionSpaces: VoxelSpace[];\n    private dimX: i32;\n    private dimY: i32;\n    private dimZ: i32;\n\n    constructor(dimX: i32, dimY: i32, dimZ: i32) {\n        this.dimX = dimX;\n        this.dimY = dimY;\n        this.dimZ = dimZ;\n        this.solutionSpaces = [];\n    }\n\n    static filterUnique(solutions: SomaSolution[]): SomaSolution[] {\n        const uniqueSolns = new Array<SomaSolution>();\n        if (solutions.length == 0) {\n            return uniqueSolns;\n        }\n        uniqueSolns.push(solutions[0]);\n        for (let iSoln = 0; iSoln < solutions.length; iSoln++) {\n            const rots = solutions[iSoln].getRotations();\n            let foundMatch = false;\n            for (let iRot = 0; iRot < rots.length; iRot++) {\n                let end = uniqueSolns.length;\n                for (let i = 0; i < end; i++) {\n                    if (rots[iRot].matches(uniqueSolns[i])) {\n                        foundMatch = true;\n                    }\n                }\n            }\n            if (!foundMatch) {\n                uniqueSolns.push(solutions[iSoln]);\n            }\n        }\n        return uniqueSolns;\n    }\n\n    getRotations(): SomaSolution[] {\n        const result: SomaSolution[] = new Array<SomaSolution>();\n        if (this.solutionSpaces.length == 0) {\n            return result;\n        }\n        const allRots: VoxelSpace[][] = this.solutionSpaces.map<VoxelSpace[]>(space => space.getAllRotations());\n        for (let i = 0; i < allRots[0].length; i++) {\n            const solnRot = new SomaSolution(this.dimX, this.dimY, this.dimZ);\n            for (let j = 0; j < allRots.length; j++) {\n                solnRot.addSpace(allRots[j][i]);\n            }\n            result.push(solnRot);\n        }\n        return result;\n    }\n\n    matches(solution: SomaSolution): boolean {\n        for (let i = 0; i < this.solutionSpaces.length; i++) {\n            if (!this.solutionSpaces[i].matches(solution.solutionSpaces[i])) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    addSpace(space: VoxelSpace): void {\n        this.solutionSpaces.push(space);\n    }\n\n    at(x: i32, y: i32, z: i32): i32 {\n        for (let i = 0; i < this.solutionSpaces.length; i++) {\n            if (this.solutionSpaces[i].at(x, y, z)) {\n                return this.solutionSpaces[i].getId();\n            }\n        }\n        return 0;\n    }\n\n    clone(): SomaSolution {\n        const clone = new SomaSolution(this.dimX, this.dimY, this.dimZ);\n        clone.solutionSpaces = this.solutionSpaces.slice(0, this.solutionSpaces.length);\n        return clone;\n    }\n\n    getPieces(): VoxelSpace[] {\n        return this.solutionSpaces;\n    }\n}","type auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid<T>(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof<T>(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl<T>(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr<T>(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret<T>(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load<T>(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store<T>(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof<T>(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof<T>(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof<T>(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof<T>(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype<T>(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert<T>(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked<T>(expr: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect<T>(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate<T>(...args: auto[]): T;\n\nexport namespace atomic {\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load<T>(ptr: usize, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store<T>(ptr: usize, value: T, immOffset?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function and<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function or<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function xor<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function notify(ptr: usize, count: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n  OK = 0,\n  NOT_EQUAL = 1,\n  TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i8 = -128;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i8 =  127;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i16 = -32768;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i16 =  32767;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i32 = -2147483648;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i32 =  2147483647;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function clz(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ctz(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_s(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_u(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotl(value: i32, shift: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotr(value: i32, shift: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_f32(value: f32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  export namespace atomic {\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function wait(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n    export namespace rmw8 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n\n    export namespace rmw16 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n\n    export namespace rmw {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i64 = -9223372036854775808;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i64 =  9223372036854775807;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function clz(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ctz(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_s(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_u(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotl(value: i64, shift: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotr(value: i64, shift: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_f64(value: f64): i64;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  export namespace atomic {\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function wait(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n\n    export namespace rmw8 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw16 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw32 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: isize = sizeof<i32>() == sizeof<isize>()\n    ? -2147483648\n    : <isize>-9223372036854775808;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: isize = sizeof<i32>() == sizeof<isize>()\n    ? 2147483647\n    : <isize>9223372036854775807;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u8 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u8 = 255;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u16 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u16 = 65535;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u32 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u32 = 4294967295;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u64 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u64 = 18446744073709551615;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: usize = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: usize = sizeof<u32>() == sizeof<usize>()\n    ? 4294967295\n    : <usize>18446744073709551615;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: bool = false;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: bool = true;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const EPSILON = reinterpret<f32>(0x34000000); // 0x1p-23f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE = reinterpret<f32>(0x00000001); // 0x0.000001p+0f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE = reinterpret<f32>(0x7F7FFFFF); // 0x1.fffffep+127f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_NORMAL_VALUE = reinterpret<f32>(0x00800000); // 0x1p-126f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_SAFE_INTEGER: f32 =  16777215;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const POSITIVE_INFINITY: f32 =  Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NaN: f32 = 0.0 / 0.0;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function copysign(x: f32, y: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_i32(value: i32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(left: f32, right: f32): f32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const EPSILON = reinterpret<f64>(0x3CB0000000000000); // 0x1p-52\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE = reinterpret<f64>(0x0000000000000001); // 0x0.0000000000001p+0\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE = reinterpret<f64>(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_NORMAL_VALUE = reinterpret<f64>(0x0010000000000000); // 0x1p-1022\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_SAFE_INTEGER: f64 =  9007199254740991;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const POSITIVE_INFINITY: f64 =  Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NaN: f64 = 0.0 / 0.0;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function copysign(x: f64, y: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_i64(value: i64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(left: f64, right: f64): f64;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n  a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n  i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat<T>(x: T): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane<T>(x: v128, idx: u8): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane<T>(x: v128, idx: u8, value: T): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function swizzle(a: v128, s: v128): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_ext<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_zero<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_lane<TFrom>(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store_lane<TFrom>(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_splat<T>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div<T>(a: v128, b: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl<T>(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr<T>(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function and(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function or(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function xor(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function andnot(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function not(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function any_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true<T>(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask<T>(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function dot<T>(a: v128, b: v128): v128; // i16 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr<T>(a: v128, b: v128): v128; // u8, u16 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_zero<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function demote_zero<T = f64>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function promote_low<T = f32>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function q15mulr_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high<T>(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n  a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n  i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(\n    a: v128, b: v128,\n    l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n    l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n  ): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function swizzle(a: v128, s: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i16): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: f32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function demote_f64x2_zero(a: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: f64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function promote_low_f32x4(a: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n  // @ts-ignore: decorator\n  @builtin\n  static new(value: i32): i31ref { return unreachable(); }\n\n  // @ts-ignore: decorator\n  @builtin\n  static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\ndeclare function abort(\n  message?: string | null,\n  fileName?: string | null,\n  lineNumber?: u32,\n  columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\ndeclare function trace(\n  message: string,\n  n?: i32,\n  a0?: f64,\n  a1?: f64,\n  a2?: f64,\n  a3?: f64,\n  a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","/// <reference path=\"./rt/index.d.ts\" />\n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n  readonly buffer: ArrayBuffer;\n  @unsafe readonly dataStart: usize;\n  readonly byteLength: i32;\n\n  get byteOffset(): i32 {\n    return <i32>(this.dataStart - changetype<usize>(this.buffer));\n  }\n\n  protected constructor(length: i32, alignLog2: i32) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n    var buffer = changetype<ArrayBuffer>(__new(length = length << alignLog2, idof<ArrayBuffer>()));\n    memory.fill(changetype<usize>(buffer), 0, <usize>length);\n    this.buffer = buffer; // links\n    this.dataStart = changetype<usize>(buffer);\n    this.byteLength = length;\n  }\n}\n\n@final export class ArrayBuffer {\n\n  static isView<T>(value: T): bool {\n    if (isNullable<T>()) {\n      if (value === null) return false;\n    }\n    if (value instanceof Int8Array) return true;\n    if (value instanceof Uint8Array) return true;\n    if (value instanceof Uint8ClampedArray) return true;\n    if (value instanceof Int16Array) return true;\n    if (value instanceof Uint16Array) return true;\n    if (value instanceof Int32Array) return true;\n    if (value instanceof Uint32Array) return true;\n    if (value instanceof Int64Array) return true;\n    if (value instanceof Uint64Array) return true;\n    if (value instanceof Float32Array) return true;\n    if (value instanceof Float64Array) return true;\n    if (value instanceof DataView) return true;\n    return false;\n  }\n\n  constructor(length: i32) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n    var buffer = changetype<ArrayBuffer>(__new(<usize>length, idof<ArrayBuffer>()));\n    memory.fill(changetype<usize>(buffer), 0, <usize>length);\n    return buffer;\n  }\n\n  get byteLength(): i32 {\n    return changetype<OBJECT>(changetype<usize>(this) - TOTAL_OVERHEAD).rtSize;\n  }\n\n  slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n    var length = this.byteLength;\n    begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n    end   = end   < 0 ? max(length + end  , 0) : min(end  , length);\n    var outSize = <usize>max(end - begin, 0);\n    var out = changetype<ArrayBuffer>(__new(outSize, idof<ArrayBuffer>()));\n    memory.copy(changetype<usize>(out), changetype<usize>(this) + <usize>begin, outSize);\n    return out;\n  }\n\n  toString(): string {\n    return \"[object ArrayBuffer]\";\n  }\n}\n","import { COMPARATOR, SORT as SORT_IMPL } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n  [key: number]: i8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i8>();\n\n  constructor(length: i32) {\n    super(length, alignof<i8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i8 {\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<i8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i8>(this.dataStart + <usize>index, value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<i8>): void {\n    store<i8>(this.dataStart + <usize>index, value);\n  }\n\n  at(index: i32): i8 {\n    var len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: i8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return FILL<Int8Array, i8>(this, value, start, end);\n  }\n\n  sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR<i8>()): Int8Array {\n    return SORT<Int8Array, i8>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return SLICE<Int8Array, i8>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return SUBARRAY<Int8Array, i8>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n    return COPY_WITHIN<Int8Array, i8>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int8Array, i8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int8Array, i8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n    return MAP<Int8Array, i8>(this, fn);\n  }\n\n  filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n    return FILTER<Int8Array, i8>(this, fn);\n  }\n\n  findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n    return FIND_INDEX<Int8Array, i8>(this, fn);\n  }\n\n  some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n    return SOME<Int8Array, i8>(this, fn);\n  }\n\n  every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n    return EVERY<Int8Array, i8>(this, fn);\n  }\n\n  forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n    FOREACH<Int8Array, i8>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, i8>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i8>(this.dataStart, this.length, separator);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Int8Array, i8, U, valueof<U>>(this, source, offset);\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n    return WRAP<Int8Array, i8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n  [key: number]: u8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();\n\n  constructor(length: i32) {\n    super(length, alignof<u8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u8 {\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u8>(this.dataStart + <usize>index, value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u8>): void {\n    store<u8>(this.dataStart + <usize>index, value);\n  }\n\n  at(index: i32): u8 {\n    var len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: u8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return FILL<Uint8Array, u8>(this, value, start, end);\n  }\n\n  sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8Array {\n    return SORT<Uint8Array, u8>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return SLICE<Uint8Array, u8>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return SUBARRAY<Uint8Array, u8>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return COPY_WITHIN<Uint8Array, u8>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint8Array, u8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint8Array, u8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n    return MAP<Uint8Array, u8>(this, fn);\n  }\n\n  filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n    return FILTER<Uint8Array, u8>(this, fn);\n  }\n\n  findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n    return FIND_INDEX<Uint8Array, u8>(this, fn);\n  }\n\n  some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n    return SOME<Uint8Array, u8>(this, fn);\n  }\n\n  every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n    return EVERY<Uint8Array, u8>(this, fn);\n  }\n\n  forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n    FOREACH<Uint8Array, u8>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u8>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u8>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint8Array, u8, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n    return WRAP<Uint8Array, u8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n  [key: number]: u8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();\n\n  constructor(length: i32) {\n    super(length, alignof<u8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u8 {\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u8>): void {\n    store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));\n  }\n\n  at(index: i32): u8 {\n    var len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: u8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return FILL<Uint8ClampedArray, u8>(this, value, start, end);\n  }\n\n  sort(fn: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8ClampedArray {\n    return SORT<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return SLICE<Uint8ClampedArray, u8>(this, begin, end);\n  }\n\n  subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return SUBARRAY<Uint8ClampedArray, u8>(this, start, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return COPY_WITHIN<Uint8ClampedArray, u8>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint8ClampedArray, u8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n    return MAP<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n    return FILTER<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n    return FIND_INDEX<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n    return SOME<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n    return EVERY<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n    FOREACH<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u8>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u8>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint8ClampedArray, u8, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n    return WRAP<Uint8ClampedArray, u8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int16Array extends ArrayBufferView {\n  [key: number]: i16;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i16>();\n\n  constructor(length: i32) {\n    super(length, alignof<i16>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i16>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i16 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i16 {\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<i16>): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<i16>): void {\n    store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);\n  }\n\n  at(index: i32): i16 {\n    var len = this.byteLength >>> alignof<i16>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  includes(searchElement: i16, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return FILL<Int16Array, i16>(this, value, start, end);\n  }\n\n  sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR<i16>()): Int16Array {\n    return SORT<Int16Array, i16>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return SLICE<Int16Array, i16>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return SUBARRAY<Int16Array, i16>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n    return COPY_WITHIN<Int16Array, i16>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int16Array, i16, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int16Array, i16, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n    return MAP<Int16Array, i16>(this, fn);\n  }\n\n  filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n    return FILTER<Int16Array, i16>(this, fn);\n  }\n\n  findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n    return FIND_INDEX<Int16Array, i16>(this, fn);\n  }\n\n  some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n    return SOME<Int16Array, i16>(this, fn);\n  }\n\n  every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n    return EVERY<Int16Array, i16>(this, fn);\n  }\n\n  forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n    FOREACH<Int16Array, i16>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, i16>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i16>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Int16Array, i16, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n    return WRAP<Int16Array, i16>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n  [key: number]: u16;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u16>();\n\n  constructor(length: i32) {\n    super(length, alignof<u16>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u16>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u16 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u16 {\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u16>): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u16>): void {\n    store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);\n  }\n\n  at(index: i32): u16 {\n    var len = this.byteLength >>> alignof<u16>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  includes(searchElement: u16, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return FILL<Uint16Array, u16>(this, value, start, end);\n  }\n\n  sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR<u16>()): Uint16Array {\n    return SORT<Uint16Array, u16>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return SLICE<Uint16Array, u16>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return SUBARRAY<Uint16Array, u16>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return COPY_WITHIN<Uint16Array, u16>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint16Array, u16, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint16Array, u16, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n    return MAP<Uint16Array, u16>(this, fn);\n  }\n\n  filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n    return FILTER<Uint16Array, u16>(this, fn);\n  }\n\n  findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n    return FIND_INDEX<Uint16Array, u16>(this, fn);\n  }\n\n  some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n    return SOME<Uint16Array, u16>(this, fn);\n  }\n\n  every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n    return EVERY<Uint16Array, u16>(this, fn);\n  }\n\n  forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n    FOREACH<Uint16Array, u16>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u16>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u16>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint16Array, u16, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n    return WRAP<Uint16Array, u16>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int32Array extends ArrayBufferView {\n  [key: number]: i32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i32>();\n\n  constructor(length: i32) {\n    super(length, alignof<i32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i32 {\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: i32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: i32): void {\n    store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);\n  }\n\n  at(index: i32): i32 {\n    var len = this.byteLength >>> alignof<i32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  includes(searchElement: i32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return FILL<Int32Array, i32>(this, value, start, end);\n  }\n\n  sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR<i32>()): Int32Array {\n    return SORT<Int32Array, i32>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return SLICE<Int32Array, i32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return SUBARRAY<Int32Array, i32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n    return COPY_WITHIN<Int32Array, i32>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int32Array, i32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int32Array, i32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n    return MAP<Int32Array, i32>(this, fn);\n  }\n\n  filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n    return FILTER<Int32Array, i32>(this, fn);\n  }\n\n  findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n    return FIND_INDEX<Int32Array, i32>(this, fn);\n  }\n\n  some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n    return SOME<Int32Array, i32>(this, fn);\n  }\n\n  every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n    return EVERY<Int32Array, i32>(this, fn);\n  }\n\n  forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n    FOREACH<Int32Array, i32>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, i32>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Int32Array, i32, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n    return WRAP<Int32Array, i32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n  [key: number]: u32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u32>();\n\n  constructor(length: i32) {\n    super(length, alignof<u32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u32 {\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: u32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: u32): void {\n    store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);\n  }\n\n  at(index: i32): u32 {\n    var len = this.byteLength >>> alignof<u32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  includes(searchElement: u32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return FILL<Uint32Array, u32>(this, value, start, end);\n  }\n\n  sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR<u32>()): Uint32Array {\n    return SORT<Uint32Array, u32>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return SLICE<Uint32Array, u32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return SUBARRAY<Uint32Array, u32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return COPY_WITHIN<Uint32Array, u32>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint32Array, u32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint32Array, u32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n    return MAP<Uint32Array, u32>(this, fn);\n  }\n\n  filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n    return FILTER<Uint32Array, u32>(this, fn);\n  }\n\n  findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n    return FIND_INDEX<Uint32Array, u32>(this, fn);\n  }\n\n  some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n    return SOME<Uint32Array, u32>(this, fn);\n  }\n\n  every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n    return EVERY<Uint32Array, u32>(this, fn);\n  }\n\n  forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n    FOREACH<Uint32Array, u32>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u32>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint32Array, u32, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n    return WRAP<Uint32Array, u32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int64Array extends ArrayBufferView {\n  [key: number]: i64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i64>();\n\n  constructor(length: i32) {\n    super(length, alignof<i64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i64 {\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: i64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: i64): void {\n    store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);\n  }\n\n  at(index: i32): i64 {\n    var len = this.byteLength >>> alignof<i64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  includes(searchElement: i64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return FILL<Int64Array, i64>(this, value, start, end);\n  }\n\n  sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR<i64>()): Int64Array {\n    return SORT<Int64Array, i64>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return SLICE<Int64Array, i64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return SUBARRAY<Int64Array, i64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n    return COPY_WITHIN<Int64Array, i64>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int64Array, i64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int64Array, i64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n    return MAP<Int64Array, i64>(this, fn);\n  }\n\n  filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n    return FILTER<Int64Array, i64>(this, fn);\n  }\n\n  findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n    return FIND_INDEX<Int64Array, i64>(this, fn);\n  }\n\n  some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n    return SOME<Int64Array, i64>(this, fn);\n  }\n\n  every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n    return EVERY<Int64Array, i64>(this, fn);\n  }\n\n  forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n    FOREACH<Int64Array, i64>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, i64>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Int64Array, i64, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n    return WRAP<Int64Array, i64>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n  [key: number]: u64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u64>();\n\n  constructor(length: i32) {\n    super(length, alignof<u64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u64 {\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: u64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: u64): void {\n    store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);\n  }\n\n  at(index: i32): u64 {\n    var len = this.byteLength >>> alignof<u64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  includes(searchElement: u64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return FILL<Uint64Array, u64>(this, value, start, end);\n  }\n\n  sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR<u64>()): Uint64Array {\n    return SORT<Uint64Array, u64>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return SLICE<Uint64Array, u64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return SUBARRAY<Uint64Array, u64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return COPY_WITHIN<Uint64Array, u64>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint64Array, u64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint64Array, u64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n    return MAP<Uint64Array, u64>(this, fn);\n  }\n\n  filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n    return FILTER<Uint64Array, u64>(this, fn);\n  }\n\n  findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n    return FIND_INDEX<Uint64Array, u64>(this, fn);\n  }\n\n  some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n    return SOME<Uint64Array, u64>(this, fn);\n  }\n\n  every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n    return EVERY<Uint64Array, u64>(this, fn);\n  }\n\n  forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n    FOREACH<Uint64Array, u64>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, u64>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Uint64Array, u64, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n    return WRAP<Uint64Array, u64>(buffer, byteOffset, length);\n  }\n}\n\nexport class Float32Array extends ArrayBufferView {\n  [key: number]: f32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<f32>();\n\n  constructor(length: i32) {\n    super(length, alignof<f32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<f32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): f32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): f32 {\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: f32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: f32): void {\n    store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);\n  }\n\n  at(index: i32): f32 {\n    var len = this.byteLength >>> alignof<f32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  includes(searchElement: f32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return FILL<Float32Array, f32>(this, value, start, end);\n  }\n\n  sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR<f32>()): Float32Array {\n    return SORT<Float32Array, f32>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return SLICE<Float32Array, f32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return SUBARRAY<Float32Array, f32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n    return COPY_WITHIN<Float32Array, f32>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Float32Array, f32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Float32Array, f32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n    return MAP<Float32Array, f32>(this, fn);\n  }\n\n  filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n    return FILTER<Float32Array, f32>(this, fn);\n  }\n\n  findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n    return FIND_INDEX<Float32Array, f32>(this, fn);\n  }\n\n  some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n    return SOME<Float32Array, f32>(this, fn);\n  }\n\n  every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n    return EVERY<Float32Array, f32>(this, fn);\n  }\n\n  forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n    FOREACH<Float32Array, f32>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, f32>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinFloatArray<f32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Float32Array, f32, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n    return WRAP<Float32Array, f32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Float64Array extends ArrayBufferView {\n  [key: number]: f64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<f64>();\n\n  constructor(length: i32) {\n    super(length, alignof<f64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<f64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): f64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): f64 {\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: f64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: f64): void {\n    store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);\n  }\n\n  at(index: i32): f64 {\n    var len = this.byteLength >>> alignof<f64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  includes(searchElement: f64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return FILL<Float64Array, f64>(this, value, start, end);\n  }\n\n  sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR<f64>()): Float64Array {\n    return SORT<Float64Array, f64>(this, comparator);\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return SLICE<Float64Array, f64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return SUBARRAY<Float64Array, f64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n    return COPY_WITHIN<Float64Array, f64>(this, target, start, end);\n  }\n\n  reduce<T>(\n    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Float64Array, f64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T>(\n    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Float64Array, f64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n    return MAP<Float64Array, f64>(this, fn);\n  }\n\n  filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n    return FILTER<Float64Array, f64>(this, fn);\n  }\n\n  findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n    return FIND_INDEX<Float64Array, f64>(this, fn);\n  }\n\n  some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n    return SOME<Float64Array, f64>(this, fn);\n  }\n\n  every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n    return EVERY<Float64Array, f64>(this, fn);\n  }\n\n  forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n    FOREACH<Float64Array, f64>(this, fn);\n  }\n\n  reverse(): this {\n    return REVERSE<this, f64>(this);\n  }\n\n  join(separator: string = \",\"): string {\n    return joinFloatArray<f64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayBufferView>(source: U, offset: i32 = 0): void {\n    SET<Float64Array, f64, U, valueof<U>>(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n    return WRAP<Float64Array, f64>(buffer, byteOffset, length);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILL<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  value: native<T>,\n  start: i32,\n  end: i32\n): TArray {\n  var dataStart = array.dataStart;\n  var len = array.length;\n  start = start < 0 ? max(len + start, 0) : min(start, len);\n  end   = end   < 0 ? max(len + end,   0) : min(end,   len);\n  if (sizeof<T>() == 1) {\n    if (start < end) memory.fill(dataStart + <usize>start, <u8>value, <usize>(end - start));\n  } else {\n    for (; start < end; ++start) {\n      store<T>(dataStart + (<usize>start << alignof<T>()), value);\n    }\n  }\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SORT<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  comparator: (a: T, b: T) => i32\n): TArray {\n  var len = array.length;\n  if (len <= 1) return array;\n  var base = array.dataStart;\n  if (len == 2) {\n    let a: T = load<T>(base, sizeof<T>()); // a = arr[1]\n    let b: T = load<T>(base); // b = arr[0]\n    if (comparator(a, b) < 0) {\n      store<T>(base, b, sizeof<T>()); // arr[1] = b\n      store<T>(base, a); // arr[0] = a\n    }\n    return array;\n  }\n  SORT_IMPL<T>(base, len, comparator);\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  start: i32,\n  end: i32\n): TArray {\n  var len = array.length;\n  start  = start < 0 ? max(start + len, 0) : min(start, len);\n  end    = end   < 0 ? max(end   + len, 0) : min(end  , len);\n  len = max(end - start, 0);\n  var slice = instantiate<TArray>(len);\n  memory.copy(\n    slice.dataStart,\n    array.dataStart + (<usize>start << alignof<T>()),\n    <usize>len << alignof<T>()\n  );\n  return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  begin: i32,\n  end: i32\n): TArray {\n  var len = array.length;\n  begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n  end   = end   < 0 ? max(len + end,   0) : min(end,   len);\n  end   = max(end, begin);\n\n  var out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  var buf = changetype<usize>(array.buffer);\n  store<usize>(changetype<usize>(out), buf, offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), buf, false);\n  store<usize>(changetype<usize>(out), array.dataStart + (<usize>begin << alignof<T>()), offsetof<TArray>(\"dataStart\"));\n  store<u32>(changetype<usize>(out), (end - begin) << alignof<T>(), offsetof<TArray>(\"byteLength\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  target: i32,\n  start: i32,\n  end: i32\n): TArray {\n  var len = array.length;\n  var dataStart = array.dataStart;\n\n  end   = min<i32>(end, len);\n  var to    = target < 0 ? max(len + target, 0) : min(target, len);\n  var from  = start < 0 ? max(len + start, 0) : min(start, len);\n  var last  = end < 0 ? max(len + end, 0) : min(end, len);\n  var count = min(last - from, len - to);\n\n  memory.copy(\n    dataStart + (<usize>to << alignof<T>()),\n    dataStart + (<usize>from << alignof<T>()),\n    <usize>count << alignof<T>()\n  );\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE<TArray extends ArrayBufferView, T, TRet>(\n  array: TArray,\n  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n  initialValue: TRet\n): TRet {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    initialValue = fn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);\n  }\n  return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT<TArray extends ArrayBufferView, T, TRet>(\n  array: TArray,\n  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n  initialValue: TRet\n): TRet {\n  var dataStart = array.dataStart;\n  for (let i = array.length - 1; i >= 0; i--) {\n    initialValue = fn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);\n  }\n  return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n  var len = array.length;\n  var dataStart = array.dataStart;\n\n  var byteLength = len << alignof<T>();\n  var out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  var buf = changetype<ArrayBuffer>(__new(byteLength, idof<ArrayBuffer>()));\n  for (let i = 0; i < len; i++) {\n    store<T>(\n      changetype<usize>(buf) + (<usize>i << alignof<T>()),\n      fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)\n    );\n  }\n  store<usize>(changetype<usize>(out), changetype<usize>(buf), offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), changetype<usize>(buf), false);\n  store<usize>(changetype<usize>(out), changetype<usize>(buf), offsetof<TArray>(\"dataStart\"));\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n  var len = array.length;\n  var out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  var buf = changetype<ArrayBuffer>(__new(len << alignof<T>(), idof<ArrayBuffer>()));\n  var dataStart  = array.dataStart;\n  var j: usize = 0;\n  for (let i = 0; i < len; i++) {\n    let value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    if (fn(value, i, array)) {\n      store<T>(\n        changetype<usize>(buf) + (j++ << alignof<T>()),\n        value\n      );\n    }\n  }\n  // shrink output buffer\n  var byteLength = j << alignof<T>();\n  var data = __renew(changetype<usize>(buf), byteLength);\n  store<usize>(changetype<usize>(out), data, offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), data, false);\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  store<usize>(changetype<usize>(out), data, offsetof<TArray>(\"dataStart\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return i;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): bool {\n  if (isFloat<T>()) {\n    let index: isize = fromIndex;\n    let length: isize = array.length;\n    if (length == 0 || index >= length) return false;\n    if (index < 0) index = max(length + index, 0);\n    let dataStart = array.dataStart;\n    while (index < length) {\n      let elem = load<T>(dataStart + (index << alignof<T>()));\n      // @ts-ignore\n      if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n      ++index;\n    }\n    return false;\n  } else {\n    return INDEX_OF<TArray, T>(array, searchElement, fromIndex) >= 0;\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): i32 {\n  var index: isize = fromIndex;\n  var length: isize = array.length;\n  if (length == 0 || index >= length) return -1;\n  if (index < 0) index = max(length + index, 0);\n  var dataStart = array.dataStart;\n  while (index < length) {\n    if (load<T>(dataStart + (index << alignof<T>())) == searchElement) return <i32>index;\n    ++index;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): i32 {\n  var index: isize = fromIndex;\n  var length: isize = array.length;\n  if (length == 0) return -1;\n  if (index < 0) index = length + index; // no need to clamp\n  else if (index >= length) index = length - 1;\n  var dataStart = array.dataStart;\n  while (index >= 0) {\n    if (load<T>(dataStart + (index << alignof<T>())) == searchElement) return <i32>index;\n    --index;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return true;\n  }\n  return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) continue;\n    return false;\n  }\n  return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH<TArray extends ArrayBufferView, T>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => void,\n): void {\n  var dataStart = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REVERSE<TArray extends ArrayBufferView, T>(array: TArray): TArray {\n  var dataStart = array.dataStart;\n  for (let front: usize = 0, back: usize = array.length - 1; front < back; ++front, --back) {\n    let frontPtr = dataStart + (front << alignof<T>());\n    let backPtr = dataStart + (back << alignof<T>());\n    let temp = load<T>(frontPtr);\n    store<T>(frontPtr, load<T>(backPtr));\n    store<T>(backPtr, temp);\n  }\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP<TArray extends ArrayBufferView, T>(\n  buffer: ArrayBuffer,\n  byteOffset: i32 = 0,\n  length: i32 = -1\n): TArray {\n  var byteLength: i32;\n  var bufferByteLength = buffer.byteLength;\n  const mask: u32 = sizeof<T>() - 1;\n  if (i32(<u32>byteOffset > <u32>bufferByteLength) | (byteOffset & mask)) {\n    throw new RangeError(E_INDEXOUTOFRANGE);\n  }\n  if (length < 0) {\n    if (length == -1) {\n      if (bufferByteLength & mask) {\n        throw new RangeError(E_INVALIDLENGTH);\n      }\n      byteLength = bufferByteLength - byteOffset;\n    } else {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n  } else {\n    byteLength = length << alignof<T>();\n    if (byteOffset + byteLength > bufferByteLength) {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n  }\n  var out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  store<usize>(changetype<usize>(out), changetype<usize>(buffer), offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), changetype<usize>(buffer), false);\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  store<usize>(changetype<usize>(out), changetype<usize>(buffer) + <usize>byteOffset, offsetof<TArray>(\"dataStart\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<TArray extends ArrayBufferView, T, UArray extends ArrayBufferView, U>(\n  target: TArray,\n  source: UArray,\n  offset: i32 = 0\n): void {\n  // need to assert at compile time that U is not a reference or a function\n  if (isReference<U>()) {\n    ERROR(E_NOTIMPLEMENTED);\n  }\n\n  // Uncaught RangeError: offset is out of bounds\n  if (offset < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n  if (source.length + offset > target.length) throw new RangeError(E_INDEXOUTOFRANGE);\n\n  // if the types align and match, use memory.copy() instead of manual loop\n  if (isInteger<T>() == isInteger<U>() && alignof<T>() == alignof<U>() &&\n    !(target instanceof Uint8ClampedArray && isSigned<U>())) {\n    memory.copy(\n      target.dataStart + (<usize>offset << alignof<T>()),\n      source.dataStart,\n      source.byteLength\n    );\n  } else {\n    let targetDataStart = target.dataStart + (<usize>offset << alignof<T>());\n    let sourceDataStart = source.dataStart;\n    let count = source.length;\n    for (let i = 0; i < count; i++) {\n      // if TArray is Uint8ClampedArray, then values must be clamped\n      if (target instanceof Uint8ClampedArray) {\n        if (isFloat<U>()) {\n          let value = load<U>(sourceDataStart + (<usize>i << alignof<U>()));\n          store<T>(\n            targetDataStart + (<usize>i << alignof<T>()),\n            isFinite<U>(value) ? <T>max<U>(0, min<U>(255, value)) : <T>0\n          );\n        } else {\n          let value = load<U>(sourceDataStart + (<usize>i << alignof<U>()));\n          if (!isSigned<U>()) {\n            store<T>(\n              targetDataStart + (<usize>i << alignof<T>()),\n              // @ts-ignore: cast to T is valid for numeric types here\n              min<U>(255, value)\n            );\n          } else if (sizeof<T>() <= 4) {\n            store<T>(\n              targetDataStart + (<usize>i << alignof<T>()),\n              // @ts-ignore: cast to T is valid for numeric types here\n              ~(<i32>value >> 31) & (((255 - <i32>value) >> 31) | value)\n            );\n          } else {\n            store<T>(\n              targetDataStart + (<usize>i << alignof<T>()),\n              // @ts-ignore: cast to T is valid for numeric types here\n              ~(<i64>value >> 63) & (((255 - <i64>value) >> 63) | value)\n            );\n          }\n        }\n        // if U is a float, then casting float to int must include a finite check\n      } else if (isFloat<U>() && !isFloat<T>()) {\n        let value = load<U>(sourceDataStart + (<usize>i << alignof<U>()));\n        // @ts-ignore: cast to T is valid for numeric types here\n        store<T>(targetDataStart + (<usize>i << alignof<T>()), isFinite<U>(value) ? <T>value : 0);\n      } else if (isFloat<T>() && !isFloat<U>()) {\n        // @ts-ignore: In this case the <T> conversion is required\n        store<T>(targetDataStart + (<usize>i << alignof<T>()), <T>load<U>(sourceDataStart + (<usize>i << alignof<U>())));\n      } else {\n        store<T>(targetDataStart + (<usize>i << alignof<T>()), load<U>(sourceDataStart + (<usize>i << alignof<U>())));\n      }\n    }\n  }\n}\n","type auto = i32;\n\n@final export abstract class Function<T> {\n  private _index: u32;\n  private _env: usize;\n\n  // @ts-ignore: this on getter\n  get index(this: T): u32 {\n    return load<u32>(changetype<usize>(this), offsetof<Function<T>>(\"_index\"));\n  }\n\n  // @ts-ignore: this on getter\n  get name(this: T): string {\n    return \"\";\n  }\n\n  // @ts-ignore: this on getter\n  get length(this: T): i32 {\n    // @ts-ignore: T is function\n    return lengthof<T>();\n  }\n\n  // @ts-ignore: T is function\n  @builtin call(thisArg: thisof<T> | null, ...args: auto[]): returnof<T> {\n    return unreachable();\n  }\n\n  toString(this: T): string {\n    return \"function() { [native code] }\";\n  }\n\n  // RT integration\n\n  @unsafe private __visit(cookie: u32): void {\n    // Env is either `null` (nop) or compiler-generated\n    __visit(this._env, cookie);\n  }\n}\n"]}
\ No newline at end of file
diff --git a/public/solver/main.js b/public/solver/main.js
index 444b8ca..d5b7e5d 100644
--- a/public/solver/main.js
+++ b/public/solver/main.js
@@ -1,107 +1,62 @@
-var t="0.7.0";const e="undefined"!=typeof BigUint64Array,r=Symbol(),n=new TextDecoder("utf-16le");function s(t,e){const r=new Uint32Array(t)[e+-4>>>2]>>>1,s=new Uint16Array(t,e,r);return r<=32?String.fromCharCode.apply(String,s):n.decode(s)}function i(t){const e={};function r(t,e){return t?s(t.buffer,e):"<yet unknown>"}const n=t.env=t.env||{};return n.abort=n.abort||function(t,s,i,o){const a=e.memory||n.memory;throw Error(`abort: ${r(a,t)} at ${r(a,s)}:${i}:${o}`)},n.trace=n.trace||function(t,s,...i){const o=e.memory||n.memory;console.log(`trace: ${r(o,t)}${s?" ":""}${i.slice(0,s).join(", ")}`)},n.seed=n.seed||Date.now,t.Math=t.Math||Math,t.Date=t.Date||Date,e}const o=function(){throw Error("Operation requires compiling with --exportRuntime")};function a(t,r){const n=r.exports,i=n.memory,a=n.table,c=n.__new||o,u=n.__pin||o,y=n.__unpin||o,l=n.__collect||o,p=n.__rtti_base,d=p?function(t){return t[p>>>2]}:o;function b(t){const e=function(t){const e=new Uint32Array(i.buffer);if((t>>>=0)>=d(e))throw Error(`invalid id: ${t}`);return e[(p+4>>>2)+2*t]}(t);if(!(7&e))throw Error(`not an array: ${t}, flags=${e}`);return e}function h(t){const e=new Uint32Array(i.buffer);if((t>>>=0)>=d(e))throw Error(`invalid id: ${t}`);return e[(p+4>>>2)+2*t+1]}function m(t){return 31-Math.clz32(t>>>6&31)}function g(t,e,r){const n=i.buffer;if(r)switch(t){case 2:return new Float32Array(n);case 3:return new Float64Array(n)}else switch(t){case 0:return new(e?Int8Array:Uint8Array)(n);case 1:return new(e?Int16Array:Uint16Array)(n);case 2:return new(e?Int32Array:Uint32Array)(n);case 3:return new(e?BigInt64Array:BigUint64Array)(n)}throw Error(`unsupported align: ${t}`)}function A(t){const e=new Uint32Array(i.buffer),r=b(e[t+-8>>>2]),n=m(r);let s=4&r?t:e[t+4>>>2];const o=2&r?e[t+12>>>2]:e[s+-4>>>2]>>>n;return g(n,2048&r,4096&r).subarray(s>>>=n,s+o)}function w(t,e,r){return new t(_(t,e,r))}function _(t,e,r){const n=i.buffer,s=new Uint32Array(n),o=s[r+4>>>2];return new t(n,o,s[o+-4>>>2]>>>e)}function T(e,r,n){t[`__get${r}`]=w.bind(null,e,n),t[`__get${r}View`]=_.bind(null,e,n)}return t.__new=c,t.__pin=u,t.__unpin=y,t.__collect=l,t.__newString=function(t){if(null==t)return 0;const e=t.length,r=c(e<<1,1),n=new Uint16Array(i.buffer);for(var s=0,o=r>>>1;s<e;++s)n[o+s]=t.charCodeAt(s);return r},t.__getString=function(t){if(!t)return null;const e=i.buffer;if(1!==new Uint32Array(e)[t+-8>>>2])throw Error(`not a string: ${t}`);return s(e,t)},t.__newArray=function(t,e){const r=b(t),n=m(r),s=e.length,o=c(s<<n,4&r?t:0);let a;if(4&r)a=o;else{u(o);const e=c(2&r?16:12,t);y(o);const l=new Uint32Array(i.buffer);l[e+0>>>2]=o,l[e+4>>>2]=o,l[e+8>>>2]=s<<n,2&r&&(l[e+12>>>2]=s),a=e}const l=g(n,2048&r,4096&r);if(16384&r)for(let t=0;t<s;++t){const r=e[t];l[(o>>>n)+t]=r}else l.set(e,o>>>n);return a},t.__getArrayView=A,t.__getArray=function(t){const e=A(t),r=e.length,n=new Array(r);for(let t=0;t<r;t++)n[t]=e[t];return n},t.__getArrayBuffer=function(t){const e=i.buffer,r=new Uint32Array(e)[t+-4>>>2];return e.slice(t,t+r)},[Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array].forEach((t=>{T(t,t.name,31-Math.clz32(t.BYTES_PER_ELEMENT))})),e&&[BigUint64Array,BigInt64Array].forEach((t=>{T(t,t.name.slice(3),3)})),t.__instanceof=function(t,e){const r=new Uint32Array(i.buffer);let n=r[t+-8>>>2];if(n<=d(r))do{if(n==e)return!0;n=h(n)}while(n);return!1},t.memory=t.memory||i,t.table=t.table||a,f(n,t)}function c(t){return"undefined"!=typeof Response&&t instanceof Response}function u(t){return t instanceof WebAssembly.Module}async function y(t,e={}){if(c(t=await t))return l(t,e);const r=u(t)?t:await WebAssembly.compile(t),n=i(e),s=await WebAssembly.instantiate(r,e);return{module:r,instance:s,exports:a(n,s)}}async function l(t,e={}){if(!WebAssembly.instantiateStreaming)return y(c(t=await t)?t.arrayBuffer():t,e);const r=i(e),n=await WebAssembly.instantiateStreaming(t,e),s=a(r,n.instance);return{...n,exports:s}}function f(t,e={}){const n=t.__argumentsLength?e=>{t.__argumentsLength.value=e}:t.__setArgumentsLength||t.__setargc||(()=>{});for(let s in t){if(!Object.prototype.hasOwnProperty.call(t,s))continue;const i=t[s];let o=s.split("."),a=e;for(;o.length>1;){let t=o.shift();Object.prototype.hasOwnProperty.call(a,t)||(a[t]={}),a=a[t]}let c=o[0],u=c.indexOf("#");if(u>=0){const e=c.substring(0,u),o=a[e];if(void 0===o||!o.prototype){const t=function(...e){return t.wrap(t.prototype.constructor(0,...e))};t.prototype={valueOf(){return this[r]}},t.wrap=function(e){return Object.create(t.prototype,{[r]:{value:e,writable:!1}})},o&&Object.getOwnPropertyNames(o).forEach((e=>Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(o,e)))),a[e]=t}if(c=c.substring(u+1),a=a[e].prototype,/^(get|set):/.test(c)){if(!Object.prototype.hasOwnProperty.call(a,c=c.substring(4))){let e=t[s.replace("set:","get:")],n=t[s.replace("get:","set:")];Object.defineProperty(a,c,{get(){return e(this[r])},set(t){n(this[r],t)},enumerable:!0})}}else"constructor"===c?(a[c]=(...t)=>(n(t.length),i(...t))).original=i:(a[c]=function(...t){return n(t.length),i(this[r],...t)}).original=i}else/^(get|set):/.test(c)?Object.prototype.hasOwnProperty.call(a,c=c.substring(4))||Object.defineProperty(a,c,{get:t[s.replace("set:","get:")],set:t[s.replace("get:","set:")],enumerable:!0}):"function"==typeof i&&i!==n?(a[c]=(...t)=>(n(t.length),i(...t))).original=i:a[c]=i}return e}var p={instantiate:y,instantiateSync:function(t,e={}){const r=u(t)?t:new WebAssembly.Module(t),n=i(e),s=new WebAssembly.Instance(r,e);return{module:r,instance:s,exports:a(n,s)}},instantiateStreaming:l,demangle:f};function d(t,e,r){return e}function b(t,e,r){return t.exports.__getArrayBuffer(e)}function h(t,e,r){return t.exports[`__get${function(t){return t.startsWith("~lib/typedarray/")?((t=t.slice("~lib/typedarray/".length)).startsWith("Big")&&(t=t.slice(3)),t):t}(r)}View`](e)}function m(t,e,r){return t.exports.__newArray(t.getTypeId(r),e)}function g(t){if(!t.startsWith("~lib/array/Array"))throw Error(`${JSON.stringify(t)} is not an array type`);return t.slice("~lib/array/Array<".length,-1)}const A=new Map([["void",{ascToJs:d,jsToAsc:d}],[/^(i|u|f)(8|16|32|64)|[ui]size|bool|externref$/,{ascToJs:d,jsToAsc:d}],["~lib/string/String",{ascToJs:function(t,e,r){return t.exports.__getString(e)},jsToAsc:function(t,e,r){return t.exports.__newString(e)}}],["~lib/typedarray/Int8Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Int16Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Int32Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint8Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint16Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint32Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Int64Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint64Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint8ClampedArray",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Float32Array",{ascToJs:b,jsToAsc:m}],["~lib/typedarray/Float64Array",{ascToJs:b,jsToAsc:m}],["~lib/arraybuffer/ArrayBuffer",{ascToJs:b,jsToAsc:function(t,e,r){const n=t.exports.__new(e.byteLength,t.getTypeId(r));return new Uint8Array(t.exports.memory.buffer,n,e.byteLength).set(new Uint8Array(e)),n}}],[/^~lib\/array\/Array<.+>$/,{ascToJs:function(t,e,r){const n=g(r),s=_(n);return t.exports.__getArray(e).map((e=>s.ascToJs(t,e,n)))},jsToAsc:function(t,e,r){const n=g(r),s=_(n),i=e.map((e=>s.jsToAsc(t,e,n)));return t.exports.__newArray(t.getTypeId(r),i)}}]]),w=new Set;function _(t){for(const[e,r]of A)if("string"!=typeof e){if(e.test(t))return r}else if(e===t)return r;return w.has(t)||(console.warn(`No converter for ${JSON.stringify(t)}, using pass-through`),w.add(t)),{ascToJs:d,jsToAsc:d}}function T(t){var e;return null===(e=_(t))||void 0===e?void 0:e.ascToJs}function j(t){var e;return null===(e=_(t))||void 0===e?void 0:e.jsToAsc}function O(t,e,r){const n=r.parameters.map(T),s=j(r.returnType);return function(...i){if(i.length!=n.length)throw Error(`Expected ${n.length} arguments, got ${i.length}`);const o=i.map(((e,s)=>n[s](t,e,r.parameters[s]))),a=e(...o);return s(t,a,r.returnType)}}function U(t,e,r){const n=r.parameters.map(j),s=T(r.returnType);return(...i)=>{if(i.length!=n.length)throw Error(`Expected ${n.length} arguments, got ${i.length}`);const o=i.map(((e,s)=>n[s](t,e,r.parameters[s]))),a=e(...o);return s(t,a,r.returnType)}}function x(t,{depth:e=Number.POSITIVE_INFINITY}={}){return e<=0||!t||"object"!=typeof t?t:Object.fromEntries(Object.entries(t).map((([t,r])=>[t,x(r,{depth:e-1})])))}function E(t){const e=WebAssembly.Module.customSections(t,"as-bind_bindings"),r=new TextDecoder("utf8").decode(new Uint8Array(e[0]));try{return JSON.parse(r)}catch(t){throw Error(`Couldn’t decode type descriptor: ${t.message}`)}}class S{constructor(){this.unboundExports={},this.exports={},this.importObject={}}getTypeId(t){if(t in this.typeDescriptor.typeIds)return this.typeDescriptor.typeIds[t].id;throw Error(`Unknown type ${JSON.stringify(t)}`)}getTypeSize(t){if(t in this.typeDescriptor.typeIds)return this.typeDescriptor.typeIds[t].byteSize;throw Error(`Unknown type ${JSON.stringify(t)}`)}_validate(){if(!WebAssembly.Module.exports(this.module).find((t=>"__new"===t.name)))throw Error("The AssemblyScript wasm module was not built with --exportRuntime, which is required.");if(1!==WebAssembly.Module.customSections(this.module,"as-bind_bindings").length)throw new Error("The AssemblyScript wasm module was not built with the as-bind transform.")}async _instantiate(t,e){this.module=await async function(t){if(t=await Promise.resolve(t),"undefined"!=typeof Response&&t instanceof Response){if(WebAssembly.compileStreaming)return WebAssembly.compileStreaming(t);t=await t.arrayBuffer()}return WebAssembly.compile(t)}(t),this._validate(),this.typeDescriptor=E(this.module),this._instantiateBindImportFunctions(e),this.loadedModule=await async function(t,e){return p.instantiate(t,e)}(this.module,this.importObject),this._instantiateBindUnboundExports()}_instantiateSync(t,e){this.module=new WebAssembly.Module(t),this._validate(),this.typeDescriptor=E(this.module),this._instantiateBindImportFunctions(e),this.loadedModule=function(t,e){return p.instantiateSync(t,e)}(this.module,this.importObject),this._instantiateBindUnboundExports()}_instantiateBindImportFunctions(t){this.importObject=x(t,{depth:2});for(const[e,r]of Object.entries(this.typeDescriptor.importedFunctions))for(const[n,s]of Object.entries(r))this.importObject[e][`__asbind_unbound_${n}`]=t[e][n],this.importObject[e][n]=O(this,t[e][n],s)}_instantiateBindUnboundExports(){const t=this.loadedModule.exports;this.exports=x(t,{depth:1});for(const[e,r]of Object.entries(this.typeDescriptor.exportedFunctions))this.exports[e]=U(this,t[e],r)}}async function I(t,e){let r=new S;return await r._instantiate(t,e),r}function $(t,e){let r=new S;return r._instantiateSync(t,e),r};
+// asbind/assemblyscript loader
+var t="0.7.0";const e="undefined"!=typeof BigUint64Array,r=Symbol(),n=new TextDecoder("utf-16le");function s(t, e){const r=new Uint32Array(t)[e+-4>>>2]>>>1,s=new Uint16Array(t,e,r);return r<=32?String.fromCharCode.apply(String,s):n.decode(s)}function i(t){const e={};function r(t, e){return t?s(t.buffer,e):"<yet unknown>"}const n=t.env=t.env||{};return n.abort=n.abort||function(t, s, i, o){const a=e.memory||n.memory;throw Error(`abort: ${r(a,t)} at ${r(a,s)}:${i}:${o}`)},n.trace=n.trace||function(t, s, ...i){const o=e.memory||n.memory;console.log(`trace: ${r(o,t)}${s?" ":""}${i.slice(0,s).join(", ")}`)},n.seed=n.seed||Date.now,t.Math=t.Math||Math,t.Date=t.Date||Date,e}const o=function(){throw Error("Operation requires compiling with --exportRuntime")};function a(t, r){const n=r.exports,i=n.memory,a=n.table,c=n.__new||o,u=n.__pin||o,y=n.__unpin||o,l=n.__collect||o,p=n.__rtti_base,d=p?function(t){return t[p>>>2]}:o;function b(t){const e=function(t){const e=new Uint32Array(i.buffer);if((t>>>=0)>=d(e))throw Error(`invalid id: ${t}`);return e[(p+4>>>2)+2*t]}(t);if(!(7&e))throw Error(`not an array: ${t}, flags=${e}`);return e}function h(t){const e=new Uint32Array(i.buffer);if((t>>>=0)>=d(e))throw Error(`invalid id: ${t}`);return e[(p+4>>>2)+2*t+1]}function m(t){return 31-Math.clz32(t>>>6&31)}function g(t, e, r){const n=i.buffer;if(r)switch(t){case 2:return new Float32Array(n);case 3:return new Float64Array(n)}else switch(t){case 0:return new(e?Int8Array:Uint8Array)(n);case 1:return new(e?Int16Array:Uint16Array)(n);case 2:return new(e?Int32Array:Uint32Array)(n);case 3:return new(e?BigInt64Array:BigUint64Array)(n)}throw Error(`unsupported align: ${t}`)}function A(t){const e=new Uint32Array(i.buffer),r=b(e[t+-8>>>2]),n=m(r);let s=4&r?t:e[t+4>>>2];const o=2&r?e[t+12>>>2]:e[s+-4>>>2]>>>n;return g(n,2048&r,4096&r).subarray(s>>>=n,s+o)}function w(t, e, r){return new t(_(t,e,r))}function _(t, e, r){const n=i.buffer,s=new Uint32Array(n),o=s[r+4>>>2];return new t(n,o,s[o+-4>>>2]>>>e)}function T(e, r, n){t[`__get${r}`]=w.bind(null,e,n),t[`__get${r}View`]=_.bind(null,e,n)}return t.__new=c,t.__pin=u,t.__unpin=y,t.__collect=l,t.__newString=function(t){if(null==t)return 0;const e=t.length,r=c(e<<1,1),n=new Uint16Array(i.buffer);for(var s=0,o=r>>>1; s<e; ++s)n[o+s]=t.charCodeAt(s);return r},t.__getString=function(t){if(!t)return null;const e=i.buffer;if(1!==new Uint32Array(e)[t+-8>>>2])throw Error(`not a string: ${t}`);return s(e,t)},t.__newArray=function(t, e){const r=b(t),n=m(r),s=e.length,o=c(s<<n,4&r?t:0);let a;if(4&r)a=o;else{u(o);const e=c(2&r?16:12,t);y(o);const l=new Uint32Array(i.buffer);l[e+0>>>2]=o,l[e+4>>>2]=o,l[e+8>>>2]=s<<n,2&r&&(l[e+12>>>2]=s),a=e}const l=g(n,2048&r,4096&r);if(16384&r)for(let t=0; t<s; ++t){const r=e[t];l[(o>>>n)+t]=r}else l.set(e,o>>>n);return a},t.__getArrayView=A,t.__getArray=function(t){const e=A(t),r=e.length,n=new Array(r);for(let t=0; t<r; t++)n[t]=e[t];return n},t.__getArrayBuffer=function(t){const e=i.buffer,r=new Uint32Array(e)[t+-4>>>2];return e.slice(t,t+r)},[Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array].forEach((t=>{T(t,t.name,31-Math.clz32(t.BYTES_PER_ELEMENT))})),e&&[BigUint64Array,BigInt64Array].forEach((t=>{T(t,t.name.slice(3),3)})),t.__instanceof=function(t, e){const r=new Uint32Array(i.buffer);let n=r[t+-8>>>2];if(n<=d(r))do{if(n==e)return!0;n=h(n)}while(n);return!1},t.memory=t.memory||i,t.table=t.table||a,f(n,t)}function c(t){return"undefined"!=typeof Response&&t instanceof Response}function u(t){return t instanceof WebAssembly.Module}async function y(t, e={}){if(c(t=await t))return l(t,e);const r=u(t)?t:await WebAssembly.compile(t),n=i(e),s=await WebAssembly.instantiate(r,e);return{module:r,instance:s,exports:a(n,s)}}async function l(t, e={}){if(!WebAssembly.instantiateStreaming)return y(c(t=await t)?t.arrayBuffer():t,e);const r=i(e),n=await WebAssembly.instantiateStreaming(t,e),s=a(r,n.instance);return{...n,exports:s}}function f(t, e={}){const n=t.__argumentsLength? e=>{t.__argumentsLength.value=e}:t.__setArgumentsLength||t.__setargc||(()=>{});for(let s in t){if(!Object.prototype.hasOwnProperty.call(t,s))continue;const i=t[s];let o=s.split("."),a=e;for(; o.length>1;){let t=o.shift();Object.prototype.hasOwnProperty.call(a,t)||(a[t]={}),a=a[t]}let c=o[0],u=c.indexOf("#");if(u>=0){const e=c.substring(0,u),o=a[e];if(void 0===o||!o.prototype){const t=function(...e){return t.wrap(t.prototype.constructor(0,...e))};t.prototype={valueOf(){return this[r]}},t.wrap=function(e){return Object.create(t.prototype,{[r]:{value:e,writable:!1}})},o&&Object.getOwnPropertyNames(o).forEach((e=>Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(o,e)))),a[e]=t}if(c=c.substring(u+1),a=a[e].prototype,/^(get|set):/.test(c)){if(!Object.prototype.hasOwnProperty.call(a,c=c.substring(4))){let e=t[s.replace("set:","get:")],n=t[s.replace("get:","set:")];Object.defineProperty(a,c,{get(){return e(this[r])},set(t){n(this[r],t)},enumerable:!0})}}else"constructor"===c?(a[c]=(...t)=>(n(t.length),i(...t))).original=i:(a[c]=function(...t){return n(t.length),i(this[r],...t)}).original=i}else/^(get|set):/.test(c)?Object.prototype.hasOwnProperty.call(a,c=c.substring(4))||Object.defineProperty(a,c,{get:t[s.replace("set:","get:")],set:t[s.replace("get:","set:")],enumerable:!0}):"function"==typeof i&&i!==n?(a[c]=(...t)=>(n(t.length),i(...t))).original=i:a[c]=i}return e}var p={instantiate:y,instantiateSync:function(t, e={}){const r=u(t)?t:new WebAssembly.Module(t),n=i(e),s=new WebAssembly.Instance(r,e);return{module:r,instance:s,exports:a(n,s)}},instantiateStreaming:l,demangle:f};function d(t, e, r){return e}function b(t, e, r){return t.exports.__getArrayBuffer(e)}function h(t, e, r){return t.exports[`__get${function(t){return t.startsWith("~lib/typedarray/")?((t=t.slice("~lib/typedarray/".length)).startsWith("Big")&&(t=t.slice(3)),t):t}(r)}View`](e)}function m(t, e, r){return t.exports.__newArray(t.getTypeId(r),e)}function g(t){if(!t.startsWith("~lib/array/Array"))throw Error(`${JSON.stringify(t)} is not an array type`);return t.slice("~lib/array/Array<".length,-1)}const A=new Map([["void",{ascToJs:d,jsToAsc:d}],[/^(i|u|f)(8|16|32|64)|[ui]size|bool|externref$/,{ascToJs:d,jsToAsc:d}],["~lib/string/String",{ascToJs:function(t, e, r){return t.exports.__getString(e)},jsToAsc:function(t, e, r){return t.exports.__newString(e)}}],["~lib/typedarray/Int8Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Int16Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Int32Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint8Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint16Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint32Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Int64Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint64Array",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Uint8ClampedArray",{ascToJs:h,jsToAsc:m}],["~lib/typedarray/Float32Array",{ascToJs:b,jsToAsc:m}],["~lib/typedarray/Float64Array",{ascToJs:b,jsToAsc:m}],["~lib/arraybuffer/ArrayBuffer",{ascToJs:b,jsToAsc:function(t, e, r){const n=t.exports.__new(e.byteLength,t.getTypeId(r));return new Uint8Array(t.exports.memory.buffer,n,e.byteLength).set(new Uint8Array(e)),n}}],[/^~lib\/array\/Array<.+>$/,{ascToJs:function(t, e, r){const n=g(r),s=_(n);return t.exports.__getArray(e).map((e=>s.ascToJs(t,e,n)))},jsToAsc:function(t, e, r){const n=g(r),s=_(n),i=e.map((e=>s.jsToAsc(t,e,n)));return t.exports.__newArray(t.getTypeId(r),i)}}]]),w=new Set;function _(t){for(const[e,r]of A)if("string"!=typeof e){if(e.test(t))return r}else if(e===t)return r;return w.has(t)||(console.warn(`No converter for ${JSON.stringify(t)}, using pass-through`),w.add(t)),{ascToJs:d,jsToAsc:d}}function T(t){var e;return null===(e=_(t))||void 0===e?void 0:e.ascToJs}function j(t){var e;return null===(e=_(t))||void 0===e?void 0:e.jsToAsc}function O(t, e, r){const n=r.parameters.map(T),s=j(r.returnType);return function(...i){if(i.length!=n.length)throw Error(`Expected ${n.length} arguments, got ${i.length}`);const o=i.map(((e, s)=>n[s](t,e,r.parameters[s]))),a=e(...o);return s(t,a,r.returnType)}}function U(t, e, r){const n=r.parameters.map(j),s=T(r.returnType);return(...i)=>{if(i.length!=n.length)throw Error(`Expected ${n.length} arguments, got ${i.length}`);const o=i.map(((e, s)=>n[s](t,e,r.parameters[s]))),a=e(...o);return s(t,a,r.returnType)}}function x(t, {depth:e=Number.POSITIVE_INFINITY}={}){return e<=0||!t||"object"!=typeof t?t:Object.fromEntries(Object.entries(t).map((([t,r])=>[t,x(r,{depth:e-1})])))}function E(t){const e=WebAssembly.Module.customSections(t,"as-bind_bindings"),r=new TextDecoder("utf8").decode(new Uint8Array(e[0]));try{return JSON.parse(r)}catch(t){throw Error(`Couldn’t decode type descriptor: ${t.message}`)}}class S{constructor(){this.unboundExports={},this.exports={},this.importObject={}}getTypeId(t){if(t in this.typeDescriptor.typeIds)return this.typeDescriptor.typeIds[t].id;throw Error(`Unknown type ${JSON.stringify(t)}`)}getTypeSize(t){if(t in this.typeDescriptor.typeIds)return this.typeDescriptor.typeIds[t].byteSize;throw Error(`Unknown type ${JSON.stringify(t)}`)}_validate(){if(!WebAssembly.Module.exports(this.module).find((t=>"__new"===t.name)))throw Error("The AssemblyScript wasm module was not built with --exportRuntime, which is required.");if(1!==WebAssembly.Module.customSections(this.module,"as-bind_bindings").length)throw new Error("The AssemblyScript wasm module was not built with the as-bind transform.")}async _instantiate(t, e){this.module=await async function(t){if(t=await Promise.resolve(t),"undefined"!=typeof Response&&t instanceof Response){if(WebAssembly.compileStreaming)return WebAssembly.compileStreaming(t);t=await t.arrayBuffer()}return WebAssembly.compile(t)}(t),this._validate(),this.typeDescriptor=E(this.module),this._instantiateBindImportFunctions(e),this.loadedModule=await async function(t, e){return p.instantiate(t,e)}(this.module,this.importObject),this._instantiateBindUnboundExports()}_instantiateSync(t, e){this.module=new WebAssembly.Module(t),this._validate(),this.typeDescriptor=E(this.module),this._instantiateBindImportFunctions(e),this.loadedModule=function(t, e){return p.instantiateSync(t,e)}(this.module,this.importObject),this._instantiateBindUnboundExports()}_instantiateBindImportFunctions(t){this.importObject=x(t,{depth:2});for(const[e,r]of Object.entries(this.typeDescriptor.importedFunctions))for(const[n,s]of Object.entries(r))this.importObject[e][`__asbind_unbound_${n}`]=t[e][n],this.importObject[e][n]=O(this,t[e][n],s)}_instantiateBindUnboundExports(){const t=this.loadedModule.exports;this.exports=x(t,{depth:1});for(const[e,r]of Object.entries(this.typeDescriptor.exportedFunctions))this.exports[e]=U(this,t[e],r)}}async function I(t, e){let r=new S;return await r._instantiate(t,e),r}function $(t, e){let r=new S;return r._instantiateSync(t,e),r};
 const instantiate = I;
 
-let solveFn;
-async function load() {
-    const file = fetch("../solver/main.wasm");
-    const instance = await instantiate(file);
-    solveFn = instance.exports.solve;
+// js solver
+async function solveFnJs(polycubes, dimX, dimY, dimZ) {
+    const solver = new SomaSolver(dimX, dimY, dimZ);
+    const voxelSpaces = new Array();
+    for (let i = 0; i < polycubes.length; i++) {
+        voxelSpaces.push(new VoxelSpaceBoolean({
+            id: i,
+            dims: [dimX, dimY, dimZ],
+            space: polycubes[i],
+            cullEmpty: true
+        }));
+    }
+    await solver.solve(voxelSpaces);
+    return solver.getSolutions();
 }
-load();
-
-self.addEventListener('message', (event) => {
-    const { polycubes, dims } = event.data;
-    const solutions = solveFn(polycubes, dims);
-    self.postMessage(solutions.map(soln => soln.toString()));
-});
-
-class SomaSolver {
-    constructor(dimension) {
-        this.solutions = [];
-        this.iterations = 0;
-        if (dimension % 1 !== 0 || dimension < 0) {
-            throw new Error("The argument 'dimension' must be a positive whole number");
+class VoxelSpaceBoolean {
+    constructor(options) {
+        this.length = options.dims[0] * options.dims[1] * options.dims[2];
+        if (!options.space) {
+            options.space = new Array(options.dims[0] * options.dims[1] * options.dims[2]);
+            options.space.fill(false);
         }
-        this.dim = dimension;
-        this.solutionCube = new VoxelSpace(0, [dimension, dimension, dimension], Array(dimension ** 3).fill(0));
-    }
-    async solve(polycubes) {
-        if (polycubes.length === 0) {
-            throw new Error("You must pass at least one polycube to solve the puzzle.");
-        }
-        let cumulativeSize = polycubes.reduce((prev, curr) => prev + curr.size(), 0);
-        if (cumulativeSize !== this.dim ** 3) {
-            throw new Error(`The polycubes passed do not add up to exactly enough units to form a cube of dimension ${this.dim}! Got: ${cumulativeSize}, need: ${this.dim ** 3}`);
-        }
-        this.solutions = [];
-        const combosWithRots = polycubes.slice(1).map(polycube => polycube.getUniqueRotations().map((rot) => rot.getAllPositionsInCube(this.dim)).flat());
-        const combos = [polycubes[0].getAllPositionsInCube(this.dim), ...combosWithRots];
-        console.log(combos.flat().length);
-        this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dim));
-        this.solutions = SomaSolution.filterUnique(this.solutions);
-    }
-    getSolutions() {
-        return this.solutions.slice();
-    }
-    backtrackSolve(workingSolution, polycubes, currentSoln) {
-        const nextCubeGroup = polycubes[0];
-        for (let i = 0; i < nextCubeGroup.length; i++) {
-            const fusionAttempt = workingSolution.plus(nextCubeGroup[i]);
-            if (fusionAttempt) {
-                const nextSoln = currentSoln.clone();
-                nextSoln.addSpace(nextCubeGroup[i]);
-                if (polycubes.length === 1) {
-                    this.solutions.push(nextSoln);
-                    currentSoln = new SomaSolution(this.dim);
-                    return;
-                }
-                else {
-                    this.backtrackSolve(fusionAttempt, polycubes.slice(1), nextSoln);
-                }
+        else if (!Array.isArray(options.space)) {
+            const newSpace = [];
+            for (let i = 0; i < this.length; i++) {
+                const mask = 1n << BigInt(i);
+                newSpace.push((options.space & mask) !== 0n);
             }
+            options.space = newSpace;
         }
-    }
-}
-
-class VoxelSpace {
-    constructor(id, dims, space, cullEmpty) {
-        if (!space) {
-            space = 0n;
-        }
-        else if (Array.isArray(space)) {
-            if (space.length !== dims[0] * dims[1] * dims[2]) {
-                throw new Error("Vals don't fit in given dimensions.");
-            }
-            space = VoxelSpace.boolArrayToBigInt(space);
-        }
-        this.id = id;
-        this.length = dims[0] * dims[1] * dims[2];
-        this.dims = dims;
-        this.space = space;
-        if (cullEmpty) {
+        this.id = options.id;
+        this.dims = options.dims;
+        this.space = options.space;
+        this.color = options.color ?? "red";
+        if (options.cullEmpty !== false) {
             this.cullEmptySpace();
         }
     }
-    static boolArrayToBigInt(boolArray) {
-        let result = 0n;
-        for (let i = 0; i < boolArray.length; i++) {
-            if (boolArray[i]) {
-                result |= BigInt(1 << i);
-            }
-        }
-        return result;
+    setColor(color) {
+        this.color = color;
+    }
+    getColor() {
+        return this.color;
     }
     binaryRep() {
-        return this.space.toString(2);
+        return this.space.reduce((prev, curr) => prev + (curr ? "1" : "0"), "");
     }
     getExtrema() {
         const extrema = {
-            xMax: -Infinity,
-            xMin: Infinity,
-            yMax: -Infinity,
-            yMin: Infinity,
-            zMax: -Infinity,
-            zMin: Infinity,
+            xMax: 0,
+            xMin: this.dims[0],
+            yMax: 0,
+            yMin: this.dims[1],
+            zMax: 0,
+            zMin: this.dims[2],
         };
         this.forEachCell((val, x, y, z) => {
             if (val) {
@@ -117,21 +72,25 @@ class VoxelSpace {
     }
     cullEmptySpace() {
         const extrema = this.getExtrema();
-        let index = 0n;
-        let newSpace = 0n;
+        const newX = extrema.xMax - extrema.xMin + 1;
+        const newY = extrema.yMax - extrema.yMin + 1;
+        const newZ = extrema.zMax - extrema.zMin + 1;
+        const newSpace = new Array(newX * newY * newZ);
+        newSpace.fill(false);
+        let index = 0;
         for (let x = extrema.xMin; x <= extrema.xMax; x++) {
             for (let y = extrema.yMin; y <= extrema.yMax; y++) {
                 for (let z = extrema.zMin; z <= extrema.zMax; z++) {
                     if (this.at(x, y, z)) {
-                        newSpace |= 1n << index;
+                        newSpace[index] = true;
                     }
                     index++;
                 }
             }
         }
-        this.dims[0] = extrema.xMax - extrema.xMin + 1;
-        this.dims[1] = extrema.yMax - extrema.yMin + 1;
-        this.dims[2] = extrema.zMax - extrema.zMin + 1;
+        this.dims[0] = newX;
+        this.dims[1] = newY;
+        this.dims[2] = newZ;
         this.space = newSpace;
     }
     forEachCell(cb) {
@@ -168,18 +127,18 @@ class VoxelSpace {
     getUniqueRotations() {
         const rotations = [];
         const refSpace = this.clone();
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('z');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('z');
         refSpace.rot90('z');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         return rotations;
     }
     getAllRotations() {
@@ -213,25 +172,23 @@ class VoxelSpace {
             }
         }
     }
-    getAllPositionsInCube(cubeDim) {
-        if ((cubeDim > 0) && (cubeDim % 1 === 0)) {
-            const cubePositions = [];
-            for (let x = 0; x < cubeDim - this.dims[0] + 1; x++) {
-                for (let y = 0; y < cubeDim - this.dims[1] + 1; y++) {
-                    for (let z = 0; z < cubeDim - this.dims[2] + 1; z++) {
-                        const cubePos = new VoxelSpace(this.id, [cubeDim, cubeDim, cubeDim]);
-                        this.forEachCell((val, rotX, rotY, rotZ) => {
-                            cubePos.set(x + rotX, y + rotY, z + rotZ, val);
-                        });
-                        cubePositions.push(cubePos);
-                    }
-                }
-            }
+    getAllPositionsInPrism(cubeDimX, cubeDimY, cubeDimZ) {
+        const cubePositions = [];
+        if (this.dims[0] > cubeDimX || this.dims[1] > cubeDimY || this.dims[2] > cubeDimZ) {
             return cubePositions;
         }
-        else {
-            throw new Error("cubeDim must be a positive integer.");
+        for (let xOffset = 0; xOffset < (cubeDimX - this.dims[0] + 1); xOffset++) {
+            for (let yOffset = 0; yOffset < (cubeDimY - this.dims[1] + 1); yOffset++) {
+                for (let zOffset = 0; zOffset < (cubeDimZ - this.dims[2] + 1); zOffset++) {
+                    const cubePos = new VoxelSpaceBoolean({ id: this.id, dims: [cubeDimX, cubeDimY, cubeDimZ], color: this.color, cullEmpty: false });
+                    this.forEachCell((val, x, y, z) => {
+                        cubePos.set(xOffset + x, yOffset + y, zOffset + z, val);
+                    });
+                    cubePositions.push(cubePos);
+                }
+            }
         }
+        return cubePositions;
     }
     matches(space) {
         const otherDims = space.getDims();
@@ -240,10 +197,14 @@ class VoxelSpace {
                 return false;
             }
         }
-        return this.space === space.getRaw();
+        const otherRaw = space.getRaw();
+        if (typeof otherRaw === "bigint") {
+            return space.binaryRep() === this.binaryRep();
+        }
+        return this.space.reduce((prev, unit, i) => (unit === otherRaw[i]) && prev, true);
     }
     clone() {
-        return new VoxelSpace(this.id, this.getDims(), this.getRaw());
+        return new VoxelSpaceBoolean({ id: this.id, dims: this.getDims(), space: this.getRaw(), color: this.getColor(), cullEmpty: false });
     }
     getAxisSpins(axis) {
         const rotations = [this.clone()];
@@ -256,7 +217,7 @@ class VoxelSpace {
         return this.dims.slice();
     }
     getRaw() {
-        return this.space;
+        return this.space.slice();
     }
     // [1, 0,  0]   [x]   [ x]
     // [0, 0, -1] * [y] = [-z]
@@ -277,24 +238,21 @@ class VoxelSpace {
         return this.dims[0] * this.dims[2] * (this.dims[1] - 1 - y) + this.dims[2] * x + z;
     }
     at(x, y, z) {
-        const mask = 1n << BigInt(this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
-        return (this.space & mask) !== 0n;
+        return this.space[this.index(x, y, z)];
+    }
+    index(x, y, z) {
+        return this.dims[1] * this.dims[2] * x + this.dims[2] * y + z;
     }
     toggle(x, y, z) {
-        const mask = BigInt(1 << this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
-        this.space ^= mask;
+        const index = this.index(x, y, z);
+        this.space[index] = !this.space[index];
     }
     set(x, y, z, val) {
-        const mask = BigInt(1 << this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
-        if (val) {
-            this.space |= mask;
-        }
-        else {
-            this.space &= ~mask;
-        }
+        this.space[this.index(x, y, z)] = val;
     }
     rotated90(dim) {
-        let newSpace = 0n;
+        const newSpace = new Array(this.dims[0] * this.dims[1] * this.dims[2]);
+        newSpace.fill(false);
         let newDims;
         let rotIndex;
         if (dim === 'x') {
@@ -311,10 +269,10 @@ class VoxelSpace {
         }
         this.forEachCell((val, i, j, k) => {
             if (val) {
-                newSpace |= BigInt(1 << rotIndex(i, j, k));
+                newSpace[rotIndex(i, j, k)] = true;
             }
         });
-        return new VoxelSpace(this.id, newDims, newSpace);
+        return new VoxelSpaceBoolean({ id: this.id, dims: newDims, space: newSpace, color: this.color, cullEmpty: false });
     }
     rot90(dim) {
         const rot = this.rotated90(dim);
@@ -322,9 +280,21 @@ class VoxelSpace {
         this.dims = rot.getDims();
     }
     plus(space) {
-        const otherSpace = space.getRaw();
-        if ((this.space | otherSpace) === (this.space ^ otherSpace)) {
-            return new VoxelSpace(this.id, this.dims, otherSpace | this.space);
+        const newSpace = new Array(this.dims[0] * this.dims[1] * this.dims[2]);
+        newSpace.fill(false);
+        let clash = false;
+        space.forEachCell((val, x, y, z) => {
+            if (this.at(x, y, z) !== val) {
+                newSpace[this.index(x, y, z)] = true;
+            }
+            else {
+                if (val) {
+                    clash = true;
+                }
+            }
+        });
+        if (!clash) {
+            return new VoxelSpaceBoolean({ id: this.id, dims: this.getDims(), space: newSpace, color: this.color, cullEmpty: false });
         }
         return null;
     }
@@ -337,4 +307,219 @@ class VoxelSpace {
         });
         return size;
     }
+    getDirectNeighbourProfile(x, y, z) {
+        let result = 0;
+        if (x < this.dims[0] - 1 && this.at(x + 1, y, z)) {
+            result += 1;
+        }
+        if (y < this.dims[1] - 1 && this.at(x, y + 1, z)) {
+            result += 2;
+        }
+        if (z < this.dims[2] - 1 && this.at(x, y, z + 1)) {
+            result += 4;
+        }
+        if (x > 0 && this.at(x - 1, y, z)) {
+            result += 8;
+        }
+        if (y > 0 && this.at(x, y - 1, z)) {
+            result += 16;
+        }
+        if (z > 0 && this.at(x, y, z - 1)) {
+            result += 32;
+        }
+        return result;
+    }
+    getAllPermutationsInPrism(prismDimX, prismDimY, prismDimZ) {
+        const rotations = this.getUniqueRotations();
+        let result = new Array();
+        for (let i = 0; i < rotations.length; i++) {
+            result = result.concat(rotations[i].getAllPositionsInPrism(prismDimX, prismDimY, prismDimZ));
+        }
+        return result;
+    }
 }
+class SomaSolver {
+    constructor(dimX, dimY, dimZ) {
+        this.visualiser = { async showSoln(soln) { }, async showSpace(cube) { } };
+        this.solutions = new Array();
+        this.iterations = 0;
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
+        this.solutionCube = new VoxelSpaceBoolean({ id: 0, dims: [dimX, dimY, dimZ], cullEmpty: false });
+    }
+    setDebug(visualiser) {
+        this.visualiser = visualiser;
+    }
+    async solve(polycubes) {
+        if (polycubes.length === 0) {
+            throw new Error("You must pass at least one polycube to solve the puzzle.");
+        }
+        this.solutions.splice(0, this.solutions.length);
+        const combosWithRots = new Array();
+        for (let i = 1; i < polycubes.length; i++) {
+            const rots = polycubes[i].getAllPermutationsInPrism(this.dimX, this.dimY, this.dimZ);
+            combosWithRots.push(rots);
+        }
+        let combos = new Array();
+        combos.push(polycubes[0].getAllPositionsInPrism(this.dimX, this.dimY, this.dimZ));
+        combos = combos.concat(combosWithRots);
+        for (const combo of combos) {
+            for (const rot of combo) {
+                await this.visualiser.showSpace(rot);
+            }
+        }
+        await this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dimX, this.dimY, this.dimZ));
+        this.solutions = SomaSolution.filterUnique(this.solutions);
+    }
+    getSolutions() {
+        return this.solutions.slice();
+    }
+    async backtrackSolve(workingSolution, polycubes, currentSoln, depth = 0) {
+        const nextCubeGroup = polycubes[0];
+        for (let i = 0; i < nextCubeGroup.length; i++) {
+            const fusionAttempt = workingSolution.plus(nextCubeGroup[i]);
+            ++this.iterations;
+            if (fusionAttempt) {
+                const nextSoln = currentSoln.clone();
+                nextSoln.addSpace(nextCubeGroup[i]);
+                await this.visualiser.showSoln(nextSoln);
+                if (polycubes.length === 1) {
+                    this.solutions.push(nextSoln);
+                    currentSoln = new SomaSolution(this.dimX, this.dimY, this.dimZ);
+                    return;
+                }
+                else {
+                    await this.backtrackSolve(fusionAttempt, polycubes.slice(1), nextSoln, depth + 1);
+                }
+            }
+        }
+    }
+}
+class SomaSolution {
+    constructor(dimX, dimY, dimZ) {
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
+        this.solutionSpaces = [];
+    }
+    static filterUnique(solutions) {
+        if (solutions.length === 0) {
+            return [];
+        }
+        const uniqueSolns = [solutions[0]];
+        for (const solution of solutions) {
+            let foundMatch = false;
+            for (const rotation of solution.getRotations()) {
+                let end = uniqueSolns.length;
+                for (let i = 0; i < end; i++) {
+                    if (rotation.matches(uniqueSolns[i])) {
+                        foundMatch = true;
+                    }
+                }
+            }
+            if (!foundMatch) {
+                uniqueSolns.push(solution);
+            }
+        }
+        return uniqueSolns;
+    }
+    getRotations() {
+        if (this.solutionSpaces.length === 0) {
+            return [];
+        }
+        const result = [];
+        const allRots = this.solutionSpaces.map(space => space.getAllRotations());
+        for (let i = 0; i < allRots[0].length; i++) {
+            const solnRot = new SomaSolution(this.dimX, this.dimY, this.dimZ);
+            allRots.forEach(rotGroup => solnRot.addSpace(rotGroup[i]));
+            result.push(solnRot);
+        }
+        return result;
+    }
+    matches(solution) {
+        for (let i = 0; i < this.solutionSpaces.length; i++) {
+            if (!this.solutionSpaces[i].matches(solution.solutionSpaces[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    addSpace(space) {
+        this.solutionSpaces.push(space);
+    }
+    print() {
+        let accum = "";
+        console.log("---");
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
+                    for (const space of this.solutionSpaces) {
+                        if (space.at(x, y, z)) {
+                            accum += space.getId();
+                        }
+                    }
+                }
+                console.log(accum);
+                accum = "";
+            }
+            if (x !== this.dimX - 1) {
+                console.log("-");
+            }
+        }
+        console.log("---");
+    }
+    at(x, y, z) {
+        for (const space of this.solutionSpaces) {
+            if (space.at(x, y, z)) {
+                return space.getId();
+            }
+        }
+        return 0;
+    }
+    clone() {
+        const clone = new SomaSolution(this.dimX, this.dimY, this.dimZ);
+        clone.solutionSpaces = this.solutionSpaces.slice();
+        return clone;
+    }
+    getDims() {
+        return [this.dimX, this.dimY, this.dimZ];
+    }
+    forEachCell(cb) {
+        loopStart: for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
+                    cb(this.at(x, y, z), x, y, z);
+                }
+            }
+        }
+    }
+    getPieces() {
+        return this.solutionSpaces.slice();
+    }
+}
+
+
+
+// init wasm
+let solveFnWasm;
+async function load() {
+    const file = fetch("../solver/main.wasm");
+    const instance = await instantiate(file);
+    solveFnWasm = instance.exports.solve;
+}
+load();
+
+// worker
+self.addEventListener('message', async (event) => {
+    const { type, polycubes, dimX, dimY, dimZ } = event.data;
+    if (type === "wasm") {
+        const solutions = solveFnWasm(polycubes, dimX, dimY, dimZ);
+        self.postMessage(solutions.map(soln => soln.toString()));
+    } else if (type === "js") {
+        const solutions = await solveFnJs(polycubes, dimX, dimY, dimZ);
+        self.postMessage({solns: solutions.map(soln => soln.getPieces().map(piece => piece.binaryRep())), log: JSON.stringify(solutions)});
+    } else {
+        self.postMessage({error: `Invalid solver type passed to worker: ${type}`})
+    }
+});
diff --git a/public/solver/main.wasm b/public/solver/main.wasm
index e6fe6c342204292cc98ef53f8007cef11ff59dbe..822c6965fa96b74fccb1001bec9f39ff4402a11d 100644
GIT binary patch
delta 4085
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

delta 6271
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

diff --git a/public/solver/main.wat b/public/solver/main.wat
new file mode 100644
index 0000000..927ebee
--- /dev/null
+++ b/public/solver/main.wat
@@ -0,0 +1,5644 @@
+(module
+ (type $i32_=>_i32 (func (param i32) (result i32)))
+ (type $i32_i32_=>_none (func (param i32 i32)))
+ (type $i32_=>_none (func (param i32)))
+ (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
+ (type $none_=>_none (func))
+ (type $i32_i32_i32_=>_none (func (param i32 i32 i32)))
+ (type $none_=>_i32 (func (result i32)))
+ (type $i32_i32_i32_i32_=>_i32 (func (param i32 i32 i32 i32) (result i32)))
+ (type $i32_i32_i32_=>_i32 (func (param i32 i32 i32) (result i32)))
+ (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32)))
+ (type $i32_i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32 i32)))
+ (type $i32_i32_i32_i32_i64_i32_=>_i32 (func (param i32 i32 i32 i32 i64 i32) (result i32)))
+ (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32)))
+ (global $~lib/rt/itcms/total (mut i32) (i32.const 0))
+ (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0))
+ (global $~lib/rt/itcms/state (mut i32) (i32.const 0))
+ (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0))
+ (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0))
+ (global $~lib/rt/itcms/iter (mut i32) (i32.const 0))
+ (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0))
+ (global $~lib/rt/itcms/white (mut i32) (i32.const 0))
+ (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0))
+ (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0))
+ (global $~lib/rt/__rtti_base i32 (i32.const 2224))
+ (global $~lib/memory/__stack_pointer (mut i32) (i32.const 18732))
+ (memory $0 1)
+ (data (i32.const 1036) "<")
+ (data (i32.const 1048) "\01\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e")
+ (data (i32.const 1100) "<")
+ (data (i32.const 1112) "\01\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s")
+ (data (i32.const 1228) "<")
+ (data (i32.const 1240) "\01\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e")
+ (data (i32.const 1292) ",")
+ (data (i32.const 1304) "\01\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s")
+ (data (i32.const 1372) "<")
+ (data (i32.const 1384) "\01\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s")
+ (data (i32.const 1436) ",")
+ (data (i32.const 1448) "\01\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h")
+ (data (i32.const 1484) ",")
+ (data (i32.const 1496) "\01\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s")
+ (data (i32.const 1532) "\8c")
+ (data (i32.const 1544) "\01\00\00\00p\00\00\00Y\00o\00u\00 \00m\00u\00s\00t\00 \00p\00a\00s\00s\00 \00a\00t\00 \00l\00e\00a\00s\00t\00 \00o\00n\00e\00 \00p\00o\00l\00y\00c\00u\00b\00e\00 \00t\00o\00 \00s\00o\00l\00v\00e\00 \00t\00h\00e\00 \00p\00u\00z\00z\00l\00e\00.")
+ (data (i32.const 1676) "<")
+ (data (i32.const 1688) "\01\00\00\00,\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00S\00o\00m\00a\00S\00o\00l\00v\00e\00r\00.\00t\00s")
+ (data (i32.const 1740) "|")
+ (data (i32.const 1752) "\01\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y")
+ (data (i32.const 1868) "\1c")
+ (data (i32.const 1900) "\1c")
+ (data (i32.const 1932) "\1c")
+ (data (i32.const 1944) "\0e\00\00\00\08\00\00\00\01")
+ (data (i32.const 1964) "<")
+ (data (i32.const 1976) "\01\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s")
+ (data (i32.const 2028) "<")
+ (data (i32.const 2040) "\01\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s")
+ (data (i32.const 2092) "<")
+ (data (i32.const 2104) "\01\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d")
+ (data (i32.const 2156) "<")
+ (data (i32.const 2168) "\01\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d")
+ (data (i32.const 2224) "\0f\00\00\00 \00\00\00\00\00\00\00 ")
+ (data (i32.const 2252) "\02\n\00\00\00\00\00\00\01\n\00\00\02\00\00\00\02A")
+ (data (i32.const 2284) " ")
+ (data (i32.const 2300) "\02A\00\00\00\00\00\00\02A\00\00\00\00\00\00 \00\00\00\00\00\00\00\02\t\00\00\00\00\00\00\02A")
+ (table $0 2 funcref)
+ (elem $0 (i32.const 1) $assembly/SomaSolution/SomaSolution#getRotations~anonymous|0)
+ (export "__new" (func $~lib/rt/itcms/__new))
+ (export "__pin" (func $~lib/rt/itcms/__pin))
+ (export "__unpin" (func $~lib/rt/itcms/__unpin))
+ (export "__collect" (func $~lib/rt/itcms/__collect))
+ (export "__rtti_base" (global $~lib/rt/__rtti_base))
+ (export "memory" (memory $0))
+ (export "solve" (func $export:assembly/index/solve))
+ (start $~start)
+ (func $~lib/rt/itcms/initLazy (param $0 i32) (result i32)
+  local.get $0
+  local.get $0
+  i32.store offset=4
+  local.get $0
+  local.get $0
+  i32.store offset=8
+  local.get $0
+ )
+ (func $~lib/rt/itcms/visitRoots
+  (local $0 i32)
+  (local $1 i32)
+  i32.const 1248
+  call $~lib/rt/itcms/__visit
+  i32.const 1456
+  call $~lib/rt/itcms/__visit
+  i32.const 1760
+  call $~lib/rt/itcms/__visit
+  i32.const 1056
+  call $~lib/rt/itcms/__visit
+  i32.const 2112
+  call $~lib/rt/itcms/__visit
+  i32.const 2176
+  call $~lib/rt/itcms/__visit
+  global.get $~lib/rt/itcms/pinSpace
+  local.tee $1
+  i32.load offset=4
+  i32.const -4
+  i32.and
+  local.set $0
+  loop $while-continue|0
+   local.get $0
+   local.get $1
+   i32.ne
+   if
+    local.get $0
+    i32.load offset=4
+    drop
+    local.get $0
+    i32.const 20
+    i32.add
+    call $~lib/rt/__visit_members
+    local.get $0
+    i32.load offset=4
+    i32.const -4
+    i32.and
+    local.set $0
+    br $while-continue|0
+   end
+  end
+ )
+ (func $~lib/rt/itcms/Object#set:color (param $0 i32) (param $1 i32)
+  local.get $0
+  local.get $1
+  local.get $0
+  i32.load offset=4
+  i32.const -4
+  i32.and
+  i32.or
+  i32.store offset=4
+ )
+ (func $~lib/rt/itcms/Object#set:next (param $0 i32) (param $1 i32)
+  local.get $0
+  local.get $1
+  local.get $0
+  i32.load offset=4
+  i32.const 3
+  i32.and
+  i32.or
+  i32.store offset=4
+ )
+ (func $~lib/rt/itcms/Object#unlink (param $0 i32)
+  (local $1 i32)
+  local.get $0
+  i32.load offset=4
+  i32.const -4
+  i32.and
+  local.tee $1
+  i32.eqz
+  if
+   local.get $0
+   i32.load offset=8
+   drop
+   return
+  end
+  local.get $1
+  local.get $0
+  i32.load offset=8
+  local.tee $0
+  i32.store offset=8
+  local.get $0
+  local.get $1
+  call $~lib/rt/itcms/Object#set:next
+ )
+ (func $~lib/rt/itcms/Object#linkTo (param $0 i32) (param $1 i32) (param $2 i32)
+  (local $3 i32)
+  local.get $1
+  i32.load offset=8
+  local.set $3
+  local.get $0
+  local.get $1
+  local.get $2
+  i32.or
+  i32.store offset=4
+  local.get $0
+  local.get $3
+  i32.store offset=8
+  local.get $3
+  local.get $0
+  call $~lib/rt/itcms/Object#set:next
+  local.get $1
+  local.get $0
+  i32.store offset=8
+ )
+ (func $~lib/rt/itcms/Object#makeGray (param $0 i32)
+  local.get $0
+  global.get $~lib/rt/itcms/iter
+  i32.eq
+  if
+   local.get $0
+   i32.load offset=8
+   global.set $~lib/rt/itcms/iter
+  end
+  local.get $0
+  call $~lib/rt/itcms/Object#unlink
+  local.get $0
+  global.get $~lib/rt/itcms/toSpace
+  local.get $0
+  i32.load offset=12
+  local.tee $0
+  i32.const 1
+  i32.le_u
+  if (result i32)
+   i32.const 1
+  else
+   local.get $0
+   i32.const 2224
+   i32.load
+   i32.gt_u
+   if
+    i32.const 1248
+    i32.const 1312
+    i32.const 22
+    i32.const 28
+    call $~lib/builtins/abort
+    unreachable
+   end
+   local.get $0
+   i32.const 3
+   i32.shl
+   i32.const 2228
+   i32.add
+   i32.load
+   i32.const 32
+   i32.and
+  end
+  if (result i32)
+   global.get $~lib/rt/itcms/white
+   i32.eqz
+  else
+   i32.const 2
+  end
+  call $~lib/rt/itcms/Object#linkTo
+ )
+ (func $~lib/rt/itcms/__visit (param $0 i32)
+  local.get $0
+  i32.eqz
+  if
+   return
+  end
+  global.get $~lib/rt/itcms/white
+  local.get $0
+  i32.const 20
+  i32.sub
+  local.tee $0
+  i32.load offset=4
+  i32.const 3
+  i32.and
+  i32.eq
+  if
+   local.get $0
+   call $~lib/rt/itcms/Object#makeGray
+   global.get $~lib/rt/itcms/visitCount
+   i32.const 1
+   i32.add
+   global.set $~lib/rt/itcms/visitCount
+  end
+ )
+ (func $~lib/rt/tlsf/removeBlock (param $0 i32) (param $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  local.get $1
+  i32.load
+  i32.const -4
+  i32.and
+  local.tee $2
+  i32.const 256
+  i32.lt_u
+  if (result i32)
+   local.get $2
+   i32.const 4
+   i32.shr_u
+  else
+   i32.const 31
+   local.get $2
+   i32.const 1073741820
+   local.get $2
+   i32.const 1073741820
+   i32.lt_u
+   select
+   local.tee $2
+   i32.clz
+   i32.sub
+   local.tee $3
+   i32.const 7
+   i32.sub
+   local.set $4
+   local.get $2
+   local.get $3
+   i32.const 4
+   i32.sub
+   i32.shr_u
+   i32.const 16
+   i32.xor
+  end
+  local.set $2
+  local.get $1
+  i32.load offset=8
+  local.set $3
+  local.get $1
+  i32.load offset=4
+  local.tee $5
+  if
+   local.get $5
+   local.get $3
+   i32.store offset=8
+  end
+  local.get $3
+  if
+   local.get $3
+   local.get $5
+   i32.store offset=4
+  end
+  local.get $1
+  local.get $0
+  local.get $2
+  local.get $4
+  i32.const 4
+  i32.shl
+  i32.add
+  i32.const 2
+  i32.shl
+  i32.add
+  i32.load offset=96
+  i32.eq
+  if
+   local.get $0
+   local.get $2
+   local.get $4
+   i32.const 4
+   i32.shl
+   i32.add
+   i32.const 2
+   i32.shl
+   i32.add
+   local.get $3
+   i32.store offset=96
+   local.get $3
+   i32.eqz
+   if
+    local.get $0
+    local.get $4
+    i32.const 2
+    i32.shl
+    i32.add
+    local.tee $3
+    i32.load offset=4
+    i32.const -2
+    local.get $2
+    i32.rotl
+    i32.and
+    local.set $1
+    local.get $3
+    local.get $1
+    i32.store offset=4
+    local.get $1
+    i32.eqz
+    if
+     local.get $0
+     local.get $0
+     i32.load
+     i32.const -2
+     local.get $4
+     i32.rotl
+     i32.and
+     i32.store
+    end
+   end
+  end
+ )
+ (func $~lib/rt/tlsf/insertBlock (param $0 i32) (param $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  local.get $1
+  i32.load
+  local.set $3
+  local.get $1
+  i32.const 4
+  i32.add
+  local.get $1
+  i32.load
+  i32.const -4
+  i32.and
+  i32.add
+  local.tee $4
+  i32.load
+  local.tee $2
+  i32.const 1
+  i32.and
+  if
+   local.get $0
+   local.get $4
+   call $~lib/rt/tlsf/removeBlock
+   local.get $1
+   local.get $3
+   i32.const 4
+   i32.add
+   local.get $2
+   i32.const -4
+   i32.and
+   i32.add
+   local.tee $3
+   i32.store
+   local.get $1
+   i32.const 4
+   i32.add
+   local.get $1
+   i32.load
+   i32.const -4
+   i32.and
+   i32.add
+   local.tee $4
+   i32.load
+   local.set $2
+  end
+  local.get $3
+  i32.const 2
+  i32.and
+  if
+   local.get $1
+   i32.const 4
+   i32.sub
+   i32.load
+   local.tee $1
+   i32.load
+   local.set $6
+   local.get $0
+   local.get $1
+   call $~lib/rt/tlsf/removeBlock
+   local.get $1
+   local.get $6
+   i32.const 4
+   i32.add
+   local.get $3
+   i32.const -4
+   i32.and
+   i32.add
+   local.tee $3
+   i32.store
+  end
+  local.get $4
+  local.get $2
+  i32.const 2
+  i32.or
+  i32.store
+  local.get $4
+  i32.const 4
+  i32.sub
+  local.get $1
+  i32.store
+  local.get $0
+  local.get $3
+  i32.const -4
+  i32.and
+  local.tee $3
+  i32.const 256
+  i32.lt_u
+  if (result i32)
+   local.get $3
+   i32.const 4
+   i32.shr_u
+  else
+   i32.const 31
+   local.get $3
+   i32.const 1073741820
+   local.get $3
+   i32.const 1073741820
+   i32.lt_u
+   select
+   local.tee $3
+   i32.clz
+   i32.sub
+   local.tee $4
+   i32.const 7
+   i32.sub
+   local.set $5
+   local.get $3
+   local.get $4
+   i32.const 4
+   i32.sub
+   i32.shr_u
+   i32.const 16
+   i32.xor
+  end
+  local.tee $3
+  local.get $5
+  i32.const 4
+  i32.shl
+  i32.add
+  i32.const 2
+  i32.shl
+  i32.add
+  i32.load offset=96
+  local.set $4
+  local.get $1
+  i32.const 0
+  i32.store offset=4
+  local.get $1
+  local.get $4
+  i32.store offset=8
+  local.get $4
+  if
+   local.get $4
+   local.get $1
+   i32.store offset=4
+  end
+  local.get $0
+  local.get $3
+  local.get $5
+  i32.const 4
+  i32.shl
+  i32.add
+  i32.const 2
+  i32.shl
+  i32.add
+  local.get $1
+  i32.store offset=96
+  local.get $0
+  local.get $0
+  i32.load
+  i32.const 1
+  local.get $5
+  i32.shl
+  i32.or
+  i32.store
+  local.get $0
+  local.get $5
+  i32.const 2
+  i32.shl
+  i32.add
+  local.tee $0
+  local.get $0
+  i32.load offset=4
+  i32.const 1
+  local.get $3
+  i32.shl
+  i32.or
+  i32.store offset=4
+ )
+ (func $~lib/rt/tlsf/addMemory (param $0 i32) (param $1 i32) (param $2 i32)
+  (local $3 i32)
+  local.get $1
+  i32.const 19
+  i32.add
+  i32.const -16
+  i32.and
+  i32.const 4
+  i32.sub
+  local.set $1
+  local.get $2
+  i32.const -16
+  i32.and
+  local.get $0
+  i32.load offset=1568
+  local.tee $2
+  if
+   local.get $2
+   local.get $1
+   i32.const 16
+   i32.sub
+   i32.eq
+   if
+    local.get $2
+    i32.load
+    local.set $3
+    local.get $1
+    i32.const 16
+    i32.sub
+    local.set $1
+   end
+  end
+  local.get $1
+  i32.sub
+  local.tee $2
+  i32.const 20
+  i32.lt_u
+  if
+   return
+  end
+  local.get $1
+  local.get $3
+  i32.const 2
+  i32.and
+  local.get $2
+  i32.const 8
+  i32.sub
+  local.tee $2
+  i32.const 1
+  i32.or
+  i32.or
+  i32.store
+  local.get $1
+  i32.const 0
+  i32.store offset=4
+  local.get $1
+  i32.const 0
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  i32.const 4
+  i32.add
+  i32.add
+  local.tee $2
+  i32.const 2
+  i32.store
+  local.get $0
+  local.get $2
+  i32.store offset=1568
+  local.get $0
+  local.get $1
+  call $~lib/rt/tlsf/insertBlock
+ )
+ (func $~lib/rt/tlsf/initialize
+  (local $0 i32)
+  (local $1 i32)
+  memory.size
+  local.tee $0
+  i32.const 1
+  i32.lt_s
+  if (result i32)
+   i32.const 1
+   local.get $0
+   i32.sub
+   memory.grow
+   i32.const 0
+   i32.lt_s
+  else
+   i32.const 0
+  end
+  if
+   unreachable
+  end
+  i32.const 18736
+  i32.const 0
+  i32.store
+  i32.const 20304
+  i32.const 0
+  i32.store
+  loop $for-loop|0
+   local.get $1
+   i32.const 23
+   i32.lt_u
+   if
+    local.get $1
+    i32.const 2
+    i32.shl
+    i32.const 18736
+    i32.add
+    i32.const 0
+    i32.store offset=4
+    i32.const 0
+    local.set $0
+    loop $for-loop|1
+     local.get $0
+     i32.const 16
+     i32.lt_u
+     if
+      local.get $0
+      local.get $1
+      i32.const 4
+      i32.shl
+      i32.add
+      i32.const 2
+      i32.shl
+      i32.const 18736
+      i32.add
+      i32.const 0
+      i32.store offset=96
+      local.get $0
+      i32.const 1
+      i32.add
+      local.set $0
+      br $for-loop|1
+     end
+    end
+    local.get $1
+    i32.const 1
+    i32.add
+    local.set $1
+    br $for-loop|0
+   end
+  end
+  i32.const 18736
+  i32.const 20308
+  memory.size
+  i32.const 16
+  i32.shl
+  call $~lib/rt/tlsf/addMemory
+  i32.const 18736
+  global.set $~lib/rt/tlsf/ROOT
+ )
+ (func $~lib/rt/itcms/step (result i32)
+  (local $0 i32)
+  (local $1 i32)
+  block $folding-inner0
+   block $break|0
+    block $case2|0
+     block $case1|0
+      block $case0|0
+       global.get $~lib/rt/itcms/state
+       br_table $case0|0 $case1|0 $case2|0 $break|0
+      end
+      i32.const 1
+      global.set $~lib/rt/itcms/state
+      i32.const 0
+      global.set $~lib/rt/itcms/visitCount
+      call $~lib/rt/itcms/visitRoots
+      global.get $~lib/rt/itcms/toSpace
+      global.set $~lib/rt/itcms/iter
+      br $folding-inner0
+     end
+     global.get $~lib/rt/itcms/white
+     i32.eqz
+     local.set $1
+     global.get $~lib/rt/itcms/iter
+     i32.load offset=4
+     i32.const -4
+     i32.and
+     local.set $0
+     loop $while-continue|1
+      local.get $0
+      global.get $~lib/rt/itcms/toSpace
+      i32.ne
+      if
+       local.get $0
+       global.set $~lib/rt/itcms/iter
+       local.get $1
+       local.get $0
+       i32.load offset=4
+       i32.const 3
+       i32.and
+       i32.ne
+       if
+        local.get $0
+        local.get $1
+        call $~lib/rt/itcms/Object#set:color
+        i32.const 0
+        global.set $~lib/rt/itcms/visitCount
+        local.get $0
+        i32.const 20
+        i32.add
+        call $~lib/rt/__visit_members
+        br $folding-inner0
+       end
+       local.get $0
+       i32.load offset=4
+       i32.const -4
+       i32.and
+       local.set $0
+       br $while-continue|1
+      end
+     end
+     i32.const 0
+     global.set $~lib/rt/itcms/visitCount
+     call $~lib/rt/itcms/visitRoots
+     global.get $~lib/rt/itcms/toSpace
+     global.get $~lib/rt/itcms/iter
+     i32.load offset=4
+     i32.const -4
+     i32.and
+     i32.eq
+     if
+      global.get $~lib/memory/__stack_pointer
+      local.set $0
+      loop $while-continue|0
+       local.get $0
+       i32.const 18732
+       i32.lt_u
+       if
+        local.get $0
+        i32.load
+        call $~lib/rt/itcms/__visit
+        local.get $0
+        i32.const 4
+        i32.add
+        local.set $0
+        br $while-continue|0
+       end
+      end
+      global.get $~lib/rt/itcms/iter
+      i32.load offset=4
+      i32.const -4
+      i32.and
+      local.set $0
+      loop $while-continue|2
+       local.get $0
+       global.get $~lib/rt/itcms/toSpace
+       i32.ne
+       if
+        local.get $1
+        local.get $0
+        i32.load offset=4
+        i32.const 3
+        i32.and
+        i32.ne
+        if
+         local.get $0
+         local.get $1
+         call $~lib/rt/itcms/Object#set:color
+         local.get $0
+         i32.const 20
+         i32.add
+         call $~lib/rt/__visit_members
+        end
+        local.get $0
+        i32.load offset=4
+        i32.const -4
+        i32.and
+        local.set $0
+        br $while-continue|2
+       end
+      end
+      global.get $~lib/rt/itcms/fromSpace
+      local.set $0
+      global.get $~lib/rt/itcms/toSpace
+      global.set $~lib/rt/itcms/fromSpace
+      local.get $0
+      global.set $~lib/rt/itcms/toSpace
+      local.get $1
+      global.set $~lib/rt/itcms/white
+      local.get $0
+      i32.load offset=4
+      i32.const -4
+      i32.and
+      global.set $~lib/rt/itcms/iter
+      i32.const 2
+      global.set $~lib/rt/itcms/state
+     end
+     br $folding-inner0
+    end
+    global.get $~lib/rt/itcms/iter
+    local.tee $0
+    global.get $~lib/rt/itcms/toSpace
+    i32.ne
+    if
+     local.get $0
+     i32.load offset=4
+     i32.const -4
+     i32.and
+     global.set $~lib/rt/itcms/iter
+     local.get $0
+     i32.load offset=4
+     drop
+     local.get $0
+     i32.const 18732
+     i32.lt_u
+     if
+      local.get $0
+      i32.const 0
+      i32.store offset=4
+      local.get $0
+      i32.const 0
+      i32.store offset=8
+     else
+      global.get $~lib/rt/itcms/total
+      local.get $0
+      i32.load
+      i32.const -4
+      i32.and
+      i32.const 4
+      i32.add
+      i32.sub
+      global.set $~lib/rt/itcms/total
+      local.get $0
+      i32.const 4
+      i32.add
+      local.tee $1
+      i32.const 18732
+      i32.ge_u
+      if
+       global.get $~lib/rt/tlsf/ROOT
+       i32.eqz
+       if
+        call $~lib/rt/tlsf/initialize
+       end
+       local.get $1
+       i32.const 4
+       i32.sub
+       local.set $0
+       local.get $1
+       i32.const 15
+       i32.and
+       i32.const 1
+       local.get $1
+       select
+       i32.eqz
+       if
+        local.get $0
+        i32.load
+        drop
+       end
+       local.get $0
+       local.get $0
+       i32.load
+       i32.const 1
+       i32.or
+       i32.store
+       global.get $~lib/rt/tlsf/ROOT
+       local.get $0
+       call $~lib/rt/tlsf/insertBlock
+      end
+     end
+     i32.const 10
+     return
+    end
+    global.get $~lib/rt/itcms/toSpace
+    global.get $~lib/rt/itcms/toSpace
+    i32.store offset=4
+    global.get $~lib/rt/itcms/toSpace
+    global.get $~lib/rt/itcms/toSpace
+    i32.store offset=8
+    i32.const 0
+    global.set $~lib/rt/itcms/state
+   end
+   i32.const 0
+   return
+  end
+  global.get $~lib/rt/itcms/visitCount
+ )
+ (func $~lib/rt/tlsf/searchBlock (param $0 i32) (param $1 i32) (result i32)
+  (local $2 i32)
+  local.get $1
+  i32.const 256
+  i32.lt_u
+  if
+   local.get $1
+   i32.const 4
+   i32.shr_u
+   local.set $1
+  else
+   i32.const 31
+   local.get $1
+   i32.const 1
+   i32.const 27
+   local.get $1
+   i32.clz
+   i32.sub
+   i32.shl
+   i32.add
+   i32.const 1
+   i32.sub
+   local.get $1
+   local.get $1
+   i32.const 536870910
+   i32.lt_u
+   select
+   local.tee $1
+   i32.clz
+   i32.sub
+   local.set $2
+   local.get $1
+   local.get $2
+   i32.const 4
+   i32.sub
+   i32.shr_u
+   i32.const 16
+   i32.xor
+   local.set $1
+   local.get $2
+   i32.const 7
+   i32.sub
+   local.set $2
+  end
+  local.get $0
+  local.get $2
+  i32.const 2
+  i32.shl
+  i32.add
+  i32.load offset=4
+  i32.const -1
+  local.get $1
+  i32.shl
+  i32.and
+  local.tee $1
+  if (result i32)
+   local.get $0
+   local.get $1
+   i32.ctz
+   local.get $2
+   i32.const 4
+   i32.shl
+   i32.add
+   i32.const 2
+   i32.shl
+   i32.add
+   i32.load offset=96
+  else
+   local.get $0
+   i32.load
+   i32.const -1
+   local.get $2
+   i32.const 1
+   i32.add
+   i32.shl
+   i32.and
+   local.tee $1
+   if (result i32)
+    local.get $0
+    local.get $1
+    i32.ctz
+    local.tee $1
+    i32.const 4
+    i32.shl
+    local.get $0
+    local.get $1
+    i32.const 2
+    i32.shl
+    i32.add
+    i32.load offset=4
+    i32.ctz
+    i32.add
+    i32.const 2
+    i32.shl
+    i32.add
+    i32.load offset=96
+   else
+    i32.const 0
+   end
+  end
+ )
+ (func $~lib/rt/tlsf/__alloc (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  global.get $~lib/rt/tlsf/ROOT
+  i32.eqz
+  if
+   call $~lib/rt/tlsf/initialize
+  end
+  global.get $~lib/rt/tlsf/ROOT
+  local.set $2
+  local.get $0
+  i32.const 1073741820
+  i32.gt_u
+  if
+   i32.const 1056
+   i32.const 1392
+   i32.const 458
+   i32.const 29
+   call $~lib/builtins/abort
+   unreachable
+  end
+  local.get $2
+  i32.const 12
+  local.get $0
+  i32.const 19
+  i32.add
+  i32.const -16
+  i32.and
+  i32.const 4
+  i32.sub
+  local.get $0
+  i32.const 12
+  i32.le_u
+  select
+  local.tee $1
+  call $~lib/rt/tlsf/searchBlock
+  local.tee $0
+  i32.eqz
+  if
+   i32.const 4
+   memory.size
+   local.tee $0
+   i32.const 16
+   i32.shl
+   i32.const 4
+   i32.sub
+   local.get $2
+   i32.load offset=1568
+   i32.ne
+   i32.shl
+   local.get $1
+   i32.const 1
+   i32.const 27
+   local.get $1
+   i32.clz
+   i32.sub
+   i32.shl
+   i32.const 1
+   i32.sub
+   i32.add
+   local.get $1
+   local.get $1
+   i32.const 536870910
+   i32.lt_u
+   select
+   i32.add
+   i32.const 65535
+   i32.add
+   i32.const -65536
+   i32.and
+   i32.const 16
+   i32.shr_u
+   local.set $3
+   local.get $0
+   local.get $3
+   local.get $0
+   local.get $3
+   i32.gt_s
+   select
+   memory.grow
+   i32.const 0
+   i32.lt_s
+   if
+    local.get $3
+    memory.grow
+    i32.const 0
+    i32.lt_s
+    if
+     unreachable
+    end
+   end
+   local.get $2
+   local.get $0
+   i32.const 16
+   i32.shl
+   memory.size
+   i32.const 16
+   i32.shl
+   call $~lib/rt/tlsf/addMemory
+   local.get $2
+   local.get $1
+   call $~lib/rt/tlsf/searchBlock
+   local.set $0
+  end
+  local.get $0
+  i32.load
+  drop
+  local.get $2
+  local.get $0
+  call $~lib/rt/tlsf/removeBlock
+  local.get $0
+  i32.load
+  local.tee $3
+  i32.const -4
+  i32.and
+  local.get $1
+  i32.sub
+  local.tee $4
+  i32.const 16
+  i32.ge_u
+  if
+   local.get $0
+   local.get $1
+   local.get $3
+   i32.const 2
+   i32.and
+   i32.or
+   i32.store
+   local.get $1
+   local.get $0
+   i32.const 4
+   i32.add
+   i32.add
+   local.tee $1
+   local.get $4
+   i32.const 4
+   i32.sub
+   i32.const 1
+   i32.or
+   i32.store
+   local.get $2
+   local.get $1
+   call $~lib/rt/tlsf/insertBlock
+  else
+   local.get $0
+   local.get $3
+   i32.const -2
+   i32.and
+   i32.store
+   local.get $0
+   i32.const 4
+   i32.add
+   local.tee $1
+   local.get $0
+   i32.load
+   i32.const -4
+   i32.and
+   i32.add
+   local.get $1
+   local.get $0
+   i32.load
+   i32.const -4
+   i32.and
+   i32.add
+   i32.load
+   i32.const -3
+   i32.and
+   i32.store
+  end
+  local.get $0
+  i32.const 4
+  i32.add
+ )
+ (func $~lib/memory/memory.fill (param $0 i32) (param $1 i32)
+  (local $2 i32)
+  block $~lib/util/memory/memset|inlined.0
+   local.get $1
+   i32.eqz
+   br_if $~lib/util/memory/memset|inlined.0
+   local.get $0
+   i32.const 0
+   i32.store8
+   local.get $0
+   local.get $1
+   i32.add
+   local.tee $2
+   i32.const 1
+   i32.sub
+   i32.const 0
+   i32.store8
+   local.get $1
+   i32.const 2
+   i32.le_u
+   br_if $~lib/util/memory/memset|inlined.0
+   local.get $0
+   i32.const 0
+   i32.store8 offset=1
+   local.get $0
+   i32.const 0
+   i32.store8 offset=2
+   local.get $2
+   i32.const 2
+   i32.sub
+   i32.const 0
+   i32.store8
+   local.get $2
+   i32.const 3
+   i32.sub
+   i32.const 0
+   i32.store8
+   local.get $1
+   i32.const 6
+   i32.le_u
+   br_if $~lib/util/memory/memset|inlined.0
+   local.get $0
+   i32.const 0
+   i32.store8 offset=3
+   local.get $2
+   i32.const 4
+   i32.sub
+   i32.const 0
+   i32.store8
+   local.get $1
+   i32.const 8
+   i32.le_u
+   br_if $~lib/util/memory/memset|inlined.0
+   local.get $0
+   i32.const 0
+   local.get $0
+   i32.sub
+   i32.const 3
+   i32.and
+   local.tee $2
+   i32.add
+   local.tee $0
+   i32.const 0
+   i32.store
+   local.get $0
+   local.get $1
+   local.get $2
+   i32.sub
+   i32.const -4
+   i32.and
+   local.tee $2
+   i32.add
+   local.tee $1
+   i32.const 4
+   i32.sub
+   i32.const 0
+   i32.store
+   local.get $2
+   i32.const 8
+   i32.le_u
+   br_if $~lib/util/memory/memset|inlined.0
+   local.get $0
+   i32.const 0
+   i32.store offset=4
+   local.get $0
+   i32.const 0
+   i32.store offset=8
+   local.get $1
+   i32.const 12
+   i32.sub
+   i32.const 0
+   i32.store
+   local.get $1
+   i32.const 8
+   i32.sub
+   i32.const 0
+   i32.store
+   local.get $2
+   i32.const 24
+   i32.le_u
+   br_if $~lib/util/memory/memset|inlined.0
+   local.get $0
+   i32.const 0
+   i32.store offset=12
+   local.get $0
+   i32.const 0
+   i32.store offset=16
+   local.get $0
+   i32.const 0
+   i32.store offset=20
+   local.get $0
+   i32.const 0
+   i32.store offset=24
+   local.get $1
+   i32.const 28
+   i32.sub
+   i32.const 0
+   i32.store
+   local.get $1
+   i32.const 24
+   i32.sub
+   i32.const 0
+   i32.store
+   local.get $1
+   i32.const 20
+   i32.sub
+   i32.const 0
+   i32.store
+   local.get $1
+   i32.const 16
+   i32.sub
+   i32.const 0
+   i32.store
+   local.get $0
+   local.get $0
+   i32.const 4
+   i32.and
+   i32.const 24
+   i32.add
+   local.tee $1
+   i32.add
+   local.set $0
+   local.get $2
+   local.get $1
+   i32.sub
+   local.set $1
+   loop $while-continue|0
+    local.get $1
+    i32.const 32
+    i32.ge_u
+    if
+     local.get $0
+     i64.const 0
+     i64.store
+     local.get $0
+     i64.const 0
+     i64.store offset=8
+     local.get $0
+     i64.const 0
+     i64.store offset=16
+     local.get $0
+     i64.const 0
+     i64.store offset=24
+     local.get $1
+     i32.const 32
+     i32.sub
+     local.set $1
+     local.get $0
+     i32.const 32
+     i32.add
+     local.set $0
+     br $while-continue|0
+    end
+   end
+  end
+ )
+ (func $~lib/rt/itcms/__new (param $0 i32) (param $1 i32) (result i32)
+  (local $2 i32)
+  local.get $0
+  i32.const 1073741804
+  i32.ge_u
+  if
+   i32.const 1056
+   i32.const 1120
+   i32.const 260
+   i32.const 31
+   call $~lib/builtins/abort
+   unreachable
+  end
+  global.get $~lib/rt/itcms/total
+  global.get $~lib/rt/itcms/threshold
+  i32.ge_u
+  if
+   block $__inlined_func$~lib/rt/itcms/interrupt
+    i32.const 2048
+    local.set $2
+    loop $do-continue|0
+     local.get $2
+     call $~lib/rt/itcms/step
+     i32.sub
+     local.set $2
+     global.get $~lib/rt/itcms/state
+     i32.eqz
+     if
+      global.get $~lib/rt/itcms/total
+      i64.extend_i32_u
+      i64.const 200
+      i64.mul
+      i64.const 100
+      i64.div_u
+      i32.wrap_i64
+      i32.const 1024
+      i32.add
+      global.set $~lib/rt/itcms/threshold
+      br $__inlined_func$~lib/rt/itcms/interrupt
+     end
+     local.get $2
+     i32.const 0
+     i32.gt_s
+     br_if $do-continue|0
+    end
+    global.get $~lib/rt/itcms/total
+    global.get $~lib/rt/itcms/total
+    global.get $~lib/rt/itcms/threshold
+    i32.sub
+    i32.const 1024
+    i32.lt_u
+    i32.const 10
+    i32.shl
+    i32.add
+    global.set $~lib/rt/itcms/threshold
+   end
+  end
+  local.get $0
+  i32.const 16
+  i32.add
+  call $~lib/rt/tlsf/__alloc
+  i32.const 4
+  i32.sub
+  local.tee $2
+  local.get $1
+  i32.store offset=12
+  local.get $2
+  local.get $0
+  i32.store offset=16
+  local.get $2
+  global.get $~lib/rt/itcms/fromSpace
+  global.get $~lib/rt/itcms/white
+  call $~lib/rt/itcms/Object#linkTo
+  global.get $~lib/rt/itcms/total
+  local.get $2
+  i32.load
+  i32.const -4
+  i32.and
+  i32.const 4
+  i32.add
+  i32.add
+  global.set $~lib/rt/itcms/total
+  local.get $2
+  i32.const 20
+  i32.add
+  local.tee $1
+  local.get $0
+  call $~lib/memory/memory.fill
+  local.get $1
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#at (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+  local.get $0
+  i64.load offset=8
+  i32.const 1
+  local.get $3
+  local.get $1
+  local.get $0
+  i32.load offset=24
+  local.get $0
+  i32.load offset=28
+  i32.mul
+  i32.mul
+  local.get $2
+  local.get $0
+  i32.load offset=28
+  i32.mul
+  i32.add
+  i32.add
+  i32.shl
+  i64.extend_i32_s
+  i64.and
+  i64.const 0
+  i64.ne
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#cullEmptySpace (param $0 i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i64)
+  (local $6 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getExtrema
+  local.tee $1
+  i32.store
+  local.get $1
+  i32.load offset=4
+  local.set $2
+  loop $for-loop|0
+   local.get $2
+   local.get $1
+   i32.load
+   i32.le_s
+   if
+    local.get $1
+    i32.load offset=12
+    local.set $3
+    loop $for-loop|1
+     local.get $3
+     local.get $1
+     i32.load offset=8
+     i32.le_s
+     if
+      local.get $1
+      i32.load offset=20
+      local.set $4
+      loop $for-loop|2
+       local.get $4
+       local.get $1
+       i32.load offset=16
+       i32.le_s
+       if
+        local.get $5
+        i64.const 1
+        local.get $6
+        i64.extend_i32_s
+        i64.shl
+        i64.or
+        local.get $5
+        local.get $0
+        local.get $2
+        local.get $3
+        local.get $4
+        call $assembly/VoxelSpace/VoxelSpace#at
+        select
+        local.set $5
+        local.get $6
+        i32.const 1
+        i32.add
+        local.set $6
+        local.get $4
+        i32.const 1
+        i32.add
+        local.set $4
+        br $for-loop|2
+       end
+      end
+      local.get $3
+      i32.const 1
+      i32.add
+      local.set $3
+      br $for-loop|1
+     end
+    end
+    local.get $2
+    i32.const 1
+    i32.add
+    local.set $2
+    br $for-loop|0
+   end
+  end
+  local.get $0
+  local.get $1
+  i32.load
+  local.get $1
+  i32.load offset=4
+  i32.sub
+  i32.const 1
+  i32.add
+  i32.store offset=20
+  local.get $0
+  local.get $1
+  i32.load offset=8
+  local.get $1
+  i32.load offset=12
+  i32.sub
+  i32.const 1
+  i32.add
+  i32.store offset=24
+  local.get $0
+  local.get $1
+  i32.load offset=16
+  local.get $1
+  i32.load offset=20
+  i32.sub
+  i32.const 1
+  i32.add
+  i32.store offset=28
+  local.get $0
+  local.get $5
+  i64.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $~lib/rt/itcms/__link (param $0 i32) (param $1 i32) (param $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  local.get $1
+  i32.eqz
+  if
+   return
+  end
+  global.get $~lib/rt/itcms/white
+  local.get $1
+  i32.const 20
+  i32.sub
+  local.tee $1
+  i32.load offset=4
+  i32.const 3
+  i32.and
+  i32.eq
+  if
+   local.get $0
+   i32.const 20
+   i32.sub
+   local.tee $0
+   i32.load offset=4
+   i32.const 3
+   i32.and
+   local.tee $3
+   local.set $4
+   local.get $3
+   global.get $~lib/rt/itcms/white
+   i32.eqz
+   i32.eq
+   if
+    local.get $0
+    local.get $1
+    local.get $2
+    select
+    call $~lib/rt/itcms/Object#makeGray
+   else
+    global.get $~lib/rt/itcms/state
+    i32.const 1
+    i32.eq
+    i32.const 0
+    local.get $4
+    i32.const 3
+    i32.eq
+    select
+    if
+     local.get $1
+     call $~lib/rt/itcms/Object#makeGray
+    end
+   end
+  end
+ )
+ (func $assembly/SomaSolver/SomaSolver#set:solutionCube (param $0 i32) (param $1 i32)
+  local.get $0
+  local.get $1
+  i32.store
+  local.get $0
+  local.get $1
+  i32.const 0
+  call $~lib/rt/itcms/__link
+ )
+ (func $assembly/SomaSolver/SomaSolver#set:solutions (param $0 i32) (param $1 i32)
+  local.get $0
+  local.get $1
+  i32.store offset=16
+  local.get $0
+  local.get $1
+  i32.const 0
+  call $~lib/rt/itcms/__link
+ )
+ (func $~lib/memory/memory.copy (param $0 i32) (param $1 i32) (param $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  block $~lib/util/memory/memmove|inlined.0
+   local.get $2
+   local.set $4
+   local.get $0
+   local.get $1
+   i32.eq
+   br_if $~lib/util/memory/memmove|inlined.0
+   local.get $0
+   local.get $1
+   i32.lt_u
+   if
+    local.get $1
+    i32.const 7
+    i32.and
+    local.get $0
+    i32.const 7
+    i32.and
+    i32.eq
+    if
+     loop $while-continue|0
+      local.get $0
+      i32.const 7
+      i32.and
+      if
+       local.get $4
+       i32.eqz
+       br_if $~lib/util/memory/memmove|inlined.0
+       local.get $4
+       i32.const 1
+       i32.sub
+       local.set $4
+       local.get $0
+       local.tee $2
+       i32.const 1
+       i32.add
+       local.set $0
+       local.get $1
+       local.tee $3
+       i32.const 1
+       i32.add
+       local.set $1
+       local.get $2
+       local.get $3
+       i32.load8_u
+       i32.store8
+       br $while-continue|0
+      end
+     end
+     loop $while-continue|1
+      local.get $4
+      i32.const 8
+      i32.ge_u
+      if
+       local.get $0
+       local.get $1
+       i64.load
+       i64.store
+       local.get $4
+       i32.const 8
+       i32.sub
+       local.set $4
+       local.get $0
+       i32.const 8
+       i32.add
+       local.set $0
+       local.get $1
+       i32.const 8
+       i32.add
+       local.set $1
+       br $while-continue|1
+      end
+     end
+    end
+    loop $while-continue|2
+     local.get $4
+     if
+      local.get $0
+      local.tee $2
+      i32.const 1
+      i32.add
+      local.set $0
+      local.get $1
+      local.tee $3
+      i32.const 1
+      i32.add
+      local.set $1
+      local.get $2
+      local.get $3
+      i32.load8_u
+      i32.store8
+      local.get $4
+      i32.const 1
+      i32.sub
+      local.set $4
+      br $while-continue|2
+     end
+    end
+   else
+    local.get $1
+    i32.const 7
+    i32.and
+    local.get $0
+    i32.const 7
+    i32.and
+    i32.eq
+    if
+     loop $while-continue|3
+      local.get $0
+      local.get $4
+      i32.add
+      i32.const 7
+      i32.and
+      if
+       local.get $4
+       i32.eqz
+       br_if $~lib/util/memory/memmove|inlined.0
+       local.get $0
+       local.get $4
+       i32.const 1
+       i32.sub
+       local.tee $4
+       i32.add
+       local.get $1
+       local.get $4
+       i32.add
+       i32.load8_u
+       i32.store8
+       br $while-continue|3
+      end
+     end
+     loop $while-continue|4
+      local.get $4
+      i32.const 8
+      i32.ge_u
+      if
+       local.get $0
+       local.get $4
+       i32.const 8
+       i32.sub
+       local.tee $4
+       i32.add
+       local.get $1
+       local.get $4
+       i32.add
+       i64.load
+       i64.store
+       br $while-continue|4
+      end
+     end
+    end
+    loop $while-continue|5
+     local.get $4
+     if
+      local.get $0
+      local.get $4
+      i32.const 1
+      i32.sub
+      local.tee $4
+      i32.add
+      local.get $1
+      local.get $4
+      i32.add
+      i32.load8_u
+      i32.store8
+      br $while-continue|5
+     end
+    end
+   end
+  end
+ )
+ (func $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push (param $0 i32) (param $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  (local $8 i32)
+  (local $9 i32)
+  local.get $0
+  i32.load offset=12
+  local.tee $8
+  i32.const 1
+  i32.add
+  local.tee $5
+  local.get $0
+  i32.load offset=8
+  local.tee $6
+  i32.const 2
+  i32.shr_u
+  i32.gt_u
+  if
+   local.get $5
+   i32.const 268435455
+   i32.gt_u
+   if
+    i32.const 1456
+    i32.const 1504
+    i32.const 17
+    i32.const 48
+    call $~lib/builtins/abort
+    unreachable
+   end
+   block $__inlined_func$~lib/rt/itcms/__renew
+    local.get $6
+    i32.const 1
+    i32.shl
+    local.tee $3
+    i32.const 1073741820
+    local.get $3
+    i32.const 1073741820
+    i32.lt_u
+    select
+    local.tee $2
+    local.get $5
+    i32.const 8
+    local.get $5
+    i32.const 8
+    i32.gt_u
+    select
+    i32.const 2
+    i32.shl
+    local.tee $3
+    local.get $2
+    local.get $3
+    i32.gt_u
+    select
+    local.tee $4
+    local.get $0
+    i32.load
+    local.tee $9
+    local.tee $2
+    i32.const 20
+    i32.sub
+    local.tee $7
+    i32.load
+    i32.const -4
+    i32.and
+    i32.const 16
+    i32.sub
+    i32.le_u
+    if
+     local.get $7
+     local.get $4
+     i32.store offset=16
+     br $__inlined_func$~lib/rt/itcms/__renew
+    end
+    local.get $4
+    local.get $7
+    i32.load offset=12
+    call $~lib/rt/itcms/__new
+    local.tee $3
+    local.get $2
+    local.get $4
+    local.get $7
+    i32.load offset=16
+    local.tee $2
+    local.get $2
+    local.get $4
+    i32.gt_u
+    select
+    call $~lib/memory/memory.copy
+    local.get $3
+    local.set $2
+   end
+   local.get $2
+   local.get $6
+   i32.add
+   local.get $4
+   local.get $6
+   i32.sub
+   call $~lib/memory/memory.fill
+   local.get $2
+   local.get $9
+   i32.ne
+   if
+    local.get $0
+    local.get $2
+    i32.store
+    local.get $0
+    local.get $2
+    i32.store offset=4
+    local.get $0
+    local.get $2
+    i32.const 0
+    call $~lib/rt/itcms/__link
+   end
+   local.get $0
+   local.get $4
+   i32.store offset=8
+  end
+  local.get $0
+  i32.load offset=4
+  local.get $8
+  i32.const 2
+  i32.shl
+  i32.add
+  local.get $1
+  i32.store
+  local.get $0
+  local.get $1
+  i32.const 1
+  call $~lib/rt/itcms/__link
+  local.get $0
+  local.get $5
+  i32.store offset=12
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#clone (param $0 i32) (result i32)
+  local.get $0
+  i32.load offset=16
+  local.get $0
+  i32.load offset=20
+  local.get $0
+  i32.load offset=24
+  local.get $0
+  i32.load offset=28
+  local.get $0
+  i64.load offset=8
+  i32.const 0
+  call $assembly/VoxelSpace/VoxelSpace#constructor
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#rotated90X (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  loop $for-loop|0
+   local.get $4
+   local.get $0
+   i32.load offset=20
+   i32.lt_s
+   if
+    i32.const 0
+    local.set $2
+    loop $for-loop|1
+     local.get $2
+     local.get $0
+     i32.load offset=24
+     i32.lt_s
+     if
+      i32.const 0
+      local.set $3
+      loop $for-loop|2
+       local.get $3
+       local.get $0
+       i32.load offset=28
+       i32.lt_s
+       if
+        local.get $0
+        local.get $4
+        local.get $2
+        local.get $3
+        call $assembly/VoxelSpace/VoxelSpace#at
+        if
+         local.get $1
+         i32.const 1
+         local.get $2
+         local.get $4
+         local.get $0
+         i32.load offset=28
+         local.get $0
+         i32.load offset=24
+         i32.mul
+         i32.mul
+         local.get $0
+         i32.load offset=24
+         local.get $0
+         i32.load offset=28
+         i32.const 1
+         i32.sub
+         local.get $3
+         i32.sub
+         i32.mul
+         i32.add
+         i32.add
+         i32.shl
+         i32.or
+         local.set $1
+        end
+        local.get $3
+        i32.const 1
+        i32.add
+        local.set $3
+        br $for-loop|2
+       end
+      end
+      local.get $2
+      i32.const 1
+      i32.add
+      local.set $2
+      br $for-loop|1
+     end
+    end
+    local.get $4
+    i32.const 1
+    i32.add
+    local.set $4
+    br $for-loop|0
+   end
+  end
+  local.get $0
+  i32.load offset=16
+  local.get $0
+  i32.load offset=20
+  local.get $0
+  i32.load offset=28
+  local.get $0
+  i32.load offset=24
+  local.get $1
+  i64.extend_i32_s
+  i32.const 0
+  call $assembly/VoxelSpace/VoxelSpace#constructor
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#matches (param $0 i32) (param $1 i32) (result i32)
+  local.get $1
+  i32.load offset=20
+  local.get $0
+  i32.load offset=20
+  i32.ne
+  if
+   i32.const 0
+   return
+  end
+  local.get $1
+  i32.load offset=24
+  local.get $0
+  i32.load offset=24
+  i32.ne
+  if
+   i32.const 0
+   return
+  end
+  local.get $1
+  i32.load offset=28
+  local.get $0
+  i32.load offset=28
+  i32.ne
+  if
+   i32.const 0
+   return
+  end
+  local.get $0
+  i64.load offset=8
+  local.get $1
+  i64.load offset=8
+  i64.eq
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#rotated90Y (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  loop $for-loop|0
+   local.get $4
+   local.get $0
+   i32.load offset=20
+   i32.lt_s
+   if
+    i32.const 0
+    local.set $2
+    loop $for-loop|1
+     local.get $2
+     local.get $0
+     i32.load offset=24
+     i32.lt_s
+     if
+      i32.const 0
+      local.set $3
+      loop $for-loop|2
+       local.get $3
+       local.get $0
+       i32.load offset=28
+       i32.lt_s
+       if
+        local.get $0
+        local.get $4
+        local.get $2
+        local.get $3
+        call $assembly/VoxelSpace/VoxelSpace#at
+        if
+         local.get $1
+         i32.const 1
+         local.get $3
+         local.get $0
+         i32.load offset=24
+         local.get $0
+         i32.load offset=20
+         i32.mul
+         i32.mul
+         local.get $2
+         local.get $0
+         i32.load offset=20
+         i32.mul
+         i32.add
+         local.get $0
+         i32.load offset=20
+         i32.const 1
+         i32.sub
+         local.get $4
+         i32.sub
+         i32.add
+         i32.shl
+         i32.or
+         local.set $1
+        end
+        local.get $3
+        i32.const 1
+        i32.add
+        local.set $3
+        br $for-loop|2
+       end
+      end
+      local.get $2
+      i32.const 1
+      i32.add
+      local.set $2
+      br $for-loop|1
+     end
+    end
+    local.get $4
+    i32.const 1
+    i32.add
+    local.set $4
+    br $for-loop|0
+   end
+  end
+  local.get $0
+  i32.load offset=16
+  local.get $0
+  i32.load offset=28
+  local.get $0
+  i32.load offset=24
+  local.get $0
+  i32.load offset=20
+  local.get $1
+  i64.extend_i32_s
+  i32.const 0
+  call $assembly/VoxelSpace/VoxelSpace#constructor
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#rot90Y (param $0 i32)
+  (local $1 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rotated90Y
+  local.tee $1
+  i32.store
+  local.get $0
+  local.get $1
+  i64.load offset=8
+  i64.store offset=8
+  local.get $0
+  local.get $1
+  i32.load offset=20
+  i32.store offset=20
+  local.get $0
+  local.get $1
+  i32.load offset=24
+  i32.store offset=24
+  local.get $0
+  local.get $1
+  i32.load offset=28
+  i32.store offset=28
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#rotated90Z (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  loop $for-loop|0
+   local.get $4
+   local.get $0
+   i32.load offset=20
+   i32.lt_s
+   if
+    i32.const 0
+    local.set $2
+    loop $for-loop|1
+     local.get $2
+     local.get $0
+     i32.load offset=24
+     i32.lt_s
+     if
+      i32.const 0
+      local.set $3
+      loop $for-loop|2
+       local.get $3
+       local.get $0
+       i32.load offset=28
+       i32.lt_s
+       if
+        local.get $0
+        local.get $4
+        local.get $2
+        local.get $3
+        call $assembly/VoxelSpace/VoxelSpace#at
+        if
+         local.get $1
+         i32.const 1
+         local.get $3
+         local.get $0
+         i32.load offset=24
+         i32.const 1
+         i32.sub
+         local.get $2
+         i32.sub
+         local.get $0
+         i32.load offset=20
+         local.get $0
+         i32.load offset=28
+         i32.mul
+         i32.mul
+         local.get $4
+         local.get $0
+         i32.load offset=28
+         i32.mul
+         i32.add
+         i32.add
+         i32.shl
+         i32.or
+         local.set $1
+        end
+        local.get $3
+        i32.const 1
+        i32.add
+        local.set $3
+        br $for-loop|2
+       end
+      end
+      local.get $2
+      i32.const 1
+      i32.add
+      local.set $2
+      br $for-loop|1
+     end
+    end
+    local.get $4
+    i32.const 1
+    i32.add
+    local.set $4
+    br $for-loop|0
+   end
+  end
+  local.get $0
+  i32.load offset=16
+  local.get $0
+  i32.load offset=24
+  local.get $0
+  i32.load offset=20
+  local.get $0
+  i32.load offset=28
+  local.get $1
+  i64.extend_i32_s
+  i32.const 0
+  call $assembly/VoxelSpace/VoxelSpace#constructor
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#rot90Z (param $0 i32)
+  (local $1 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rotated90Z
+  local.tee $1
+  i32.store
+  local.get $0
+  local.get $1
+  i64.load offset=8
+  i64.store offset=8
+  local.get $0
+  local.get $1
+  i32.load offset=20
+  i32.store offset=20
+  local.get $0
+  local.get $1
+  i32.load offset=24
+  i32.store offset=24
+  local.get $0
+  local.get $1
+  i32.load offset=28
+  i32.store offset=28
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $assembly/SomaSolution/SomaSolution#getRotations~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getAllRotations
+ )
+ (func $~lib/rt/itcms/__pin (param $0 i32) (result i32)
+  (local $1 i32)
+  local.get $0
+  if
+   local.get $0
+   i32.const 20
+   i32.sub
+   local.tee $1
+   i32.load offset=4
+   i32.const 3
+   i32.and
+   i32.const 3
+   i32.eq
+   if
+    i32.const 2112
+    i32.const 1120
+    i32.const 337
+    i32.const 7
+    call $~lib/builtins/abort
+    unreachable
+   end
+   local.get $1
+   call $~lib/rt/itcms/Object#unlink
+   local.get $1
+   global.get $~lib/rt/itcms/pinSpace
+   i32.const 3
+   call $~lib/rt/itcms/Object#linkTo
+  end
+  local.get $0
+ )
+ (func $~lib/rt/itcms/__unpin (param $0 i32)
+  local.get $0
+  i32.eqz
+  if
+   return
+  end
+  local.get $0
+  i32.const 20
+  i32.sub
+  local.tee $0
+  i32.load offset=4
+  i32.const 3
+  i32.and
+  i32.const 3
+  i32.ne
+  if
+   i32.const 2176
+   i32.const 1120
+   i32.const 351
+   i32.const 5
+   call $~lib/builtins/abort
+   unreachable
+  end
+  global.get $~lib/rt/itcms/state
+  i32.const 1
+  i32.eq
+  if
+   local.get $0
+   call $~lib/rt/itcms/Object#makeGray
+  else
+   local.get $0
+   call $~lib/rt/itcms/Object#unlink
+   local.get $0
+   global.get $~lib/rt/itcms/fromSpace
+   global.get $~lib/rt/itcms/white
+   call $~lib/rt/itcms/Object#linkTo
+  end
+ )
+ (func $~lib/rt/itcms/__collect
+  global.get $~lib/rt/itcms/state
+  i32.const 0
+  i32.gt_s
+  if
+   loop $while-continue|0
+    global.get $~lib/rt/itcms/state
+    if
+     call $~lib/rt/itcms/step
+     drop
+     br $while-continue|0
+    end
+   end
+  end
+  call $~lib/rt/itcms/step
+  drop
+  loop $while-continue|1
+   global.get $~lib/rt/itcms/state
+   if
+    call $~lib/rt/itcms/step
+    drop
+    br $while-continue|1
+   end
+  end
+  global.get $~lib/rt/itcms/total
+  i64.extend_i32_u
+  i64.const 200
+  i64.mul
+  i64.const 100
+  i64.div_u
+  i32.wrap_i64
+  i32.const 1024
+  i32.add
+  global.set $~lib/rt/itcms/threshold
+ )
+ (func $~lib/rt/__visit_members (param $0 i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  block $folding-inner0
+   block $folding-inner3
+    block $folding-inner2
+     block $invalid
+      block $~lib/function/Function<%28assembly/VoxelSpace/VoxelSpace%2Ci32%2C~lib/array/Array<assembly/VoxelSpace/VoxelSpace>%29=>~lib/array/Array<assembly/VoxelSpace/VoxelSpace>>
+       block $assembly/VoxelSpace/Extrema
+        block $assembly/VoxelSpace/VoxelSpace
+         block $assembly/SomaSolver/SomaSolver
+          block $~lib/string/String
+           block $~lib/arraybuffer/ArrayBuffer
+            local.get $0
+            i32.const 8
+            i32.sub
+            i32.load
+            br_table $~lib/arraybuffer/ArrayBuffer $~lib/string/String $folding-inner3 $folding-inner0 $folding-inner3 $folding-inner2 $assembly/SomaSolver/SomaSolver $assembly/VoxelSpace/VoxelSpace $folding-inner3 $folding-inner2 $folding-inner2 $assembly/VoxelSpace/Extrema $folding-inner0 $folding-inner2 $~lib/function/Function<%28assembly/VoxelSpace/VoxelSpace%2Ci32%2C~lib/array/Array<assembly/VoxelSpace/VoxelSpace>%29=>~lib/array/Array<assembly/VoxelSpace/VoxelSpace>> $invalid
+           end
+           return
+          end
+          return
+         end
+         local.get $0
+         i32.load
+         local.tee $1
+         if
+          local.get $1
+          call $~lib/rt/itcms/__visit
+         end
+         local.get $0
+         i32.load offset=16
+         local.tee $0
+         if
+          local.get $0
+          call $~lib/rt/itcms/__visit
+         end
+         return
+        end
+        return
+       end
+       return
+      end
+      local.get $0
+      i32.load offset=4
+      call $~lib/rt/itcms/__visit
+      return
+     end
+     unreachable
+    end
+    local.get $0
+    i32.load offset=4
+    local.tee $1
+    local.get $0
+    i32.load offset=12
+    i32.const 2
+    i32.shl
+    i32.add
+    local.set $2
+    loop $while-continue|0
+     local.get $1
+     local.get $2
+     i32.lt_u
+     if
+      local.get $1
+      i32.load
+      local.tee $3
+      if
+       local.get $3
+       call $~lib/rt/itcms/__visit
+      end
+      local.get $1
+      i32.const 4
+      i32.add
+      local.set $1
+      br $while-continue|0
+     end
+    end
+    br $folding-inner0
+   end
+   local.get $0
+   i32.load
+   local.tee $0
+   if
+    local.get $0
+    call $~lib/rt/itcms/__visit
+   end
+   return
+  end
+  local.get $0
+  i32.load
+  call $~lib/rt/itcms/__visit
+ )
+ (func $~start
+  memory.size
+  i32.const 16
+  i32.shl
+  i32.const 18732
+  i32.sub
+  i32.const 1
+  i32.shr_u
+  global.set $~lib/rt/itcms/threshold
+  i32.const 1168
+  call $~lib/rt/itcms/initLazy
+  global.set $~lib/rt/itcms/pinSpace
+  i32.const 1200
+  call $~lib/rt/itcms/initLazy
+  global.set $~lib/rt/itcms/toSpace
+  i32.const 1344
+  call $~lib/rt/itcms/initLazy
+  global.set $~lib/rt/itcms/fromSpace
+ )
+ (func $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 2348
+  i32.lt_s
+  if
+   i32.const 18752
+   i32.const 18800
+   i32.const 1
+   i32.const 1
+   call $~lib/builtins/abort
+   unreachable
+  end
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#getXAxisSpins (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#constructor
+  local.tee $1
+  i32.store
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#clone
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store offset=4
+  local.get $1
+  local.get $0
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+  loop $for-loop|0
+   local.get $2
+   i32.const 3
+   i32.lt_s
+   if
+    local.get $1
+    local.get $2
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+    local.set $0
+    global.get $~lib/memory/__stack_pointer
+    local.get $0
+    i32.store offset=4
+    local.get $0
+    call $assembly/VoxelSpace/VoxelSpace#rotated90X
+    local.set $0
+    global.get $~lib/memory/__stack_pointer
+    local.get $0
+    i32.store offset=4
+    local.get $1
+    local.get $0
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+    local.get $2
+    i32.const 1
+    i32.add
+    local.set $2
+    br $for-loop|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $1
+ )
+ (func $assembly/VoxelSpace/VoxelSpace.pushNewUniqueSpaces (param $0 i32) (param $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  loop $for-loop|0
+   local.get $3
+   local.get $1
+   i32.load offset=12
+   i32.lt_s
+   if
+    i32.const 0
+    local.set $4
+    i32.const 0
+    local.set $2
+    loop $for-loop|1
+     local.get $2
+     local.get $0
+     i32.load offset=12
+     i32.lt_s
+     if
+      block $for-break1
+       local.get $1
+       local.get $3
+       call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+       local.set $5
+       global.get $~lib/memory/__stack_pointer
+       local.get $5
+       i32.store
+       local.get $0
+       local.get $2
+       call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+       local.set $6
+       global.get $~lib/memory/__stack_pointer
+       local.get $6
+       i32.store offset=4
+       local.get $5
+       local.get $6
+       call $assembly/VoxelSpace/VoxelSpace#matches
+       if
+        i32.const 1
+        local.set $4
+        br $for-break1
+       end
+       local.get $2
+       i32.const 1
+       i32.add
+       local.set $2
+       br $for-loop|1
+      end
+     end
+    end
+    local.get $4
+    i32.eqz
+    if
+     local.get $1
+     local.get $3
+     call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+     local.set $2
+     global.get $~lib/memory/__stack_pointer
+     local.get $2
+     i32.store offset=4
+     local.get $0
+     local.get $2
+     call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+    end
+    local.get $3
+    i32.const 1
+    i32.add
+    local.set $3
+    br $for-loop|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#getUniqueRotations (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 12
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#constructor
+  local.tee $2
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#clone
+  local.tee $0
+  i32.store offset=4
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $assembly/VoxelSpace/VoxelSpace.pushNewUniqueSpaces
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Y
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $assembly/VoxelSpace/VoxelSpace.pushNewUniqueSpaces
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Y
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $assembly/VoxelSpace/VoxelSpace.pushNewUniqueSpaces
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Y
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $assembly/VoxelSpace/VoxelSpace.pushNewUniqueSpaces
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Z
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $assembly/VoxelSpace/VoxelSpace.pushNewUniqueSpaces
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Z
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Z
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store offset=8
+  local.get $2
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace.pushNewUniqueSpaces
+  global.get $~lib/memory/__stack_pointer
+  i32.const 12
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $2
+ )
+ (func $assembly/SomaSolution/SomaSolution#addSpace (param $0 i32) (param $1 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load
+  local.tee $0
+  i32.store
+  local.get $0
+  local.get $1
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $assembly/SomaSolver/SomaSolver#backtrackSolve (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  (local $8 i32)
+  (local $9 i32)
+  (local $10 i32)
+  (local $11 i32)
+  (local $12 i32)
+  (local $13 i64)
+  (local $14 i32)
+  (local $15 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 28
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store offset=16
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store offset=24
+  global.get $~lib/memory/__stack_pointer
+  local.get $2
+  i32.const 0
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+  local.tee $11
+  i32.store
+  loop $for-loop|0
+   local.get $9
+   local.get $11
+   i32.load offset=12
+   i32.lt_s
+   if
+    global.get $~lib/memory/__stack_pointer
+    local.get $11
+    local.get $9
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+    local.set $5
+    global.get $~lib/memory/__stack_pointer
+    local.get $5
+    i32.store offset=4
+    block $__inlined_func$assembly/VoxelSpace/VoxelSpace#plus (result i32)
+     local.get $5
+     i64.load offset=8
+     local.tee $13
+     local.get $1
+     i64.load offset=8
+     i64.or
+     local.get $13
+     local.get $1
+     i64.load offset=8
+     i64.xor
+     i64.eq
+     if
+      local.get $1
+      i32.load offset=16
+      local.get $1
+      i32.load offset=20
+      local.get $1
+      i32.load offset=24
+      local.get $1
+      i32.load offset=28
+      local.get $13
+      local.get $1
+      i64.load offset=8
+      i64.or
+      i32.const 0
+      call $assembly/VoxelSpace/VoxelSpace#constructor
+      br $__inlined_func$assembly/VoxelSpace/VoxelSpace#plus
+     end
+     i32.const 0
+    end
+    local.tee $10
+    i32.store offset=8
+    local.get $10
+    if
+     global.get $~lib/memory/__stack_pointer
+     global.get $~lib/memory/__stack_pointer
+     i32.const 12
+     i32.sub
+     global.set $~lib/memory/__stack_pointer
+     call $~stack_check
+     global.get $~lib/memory/__stack_pointer
+     i64.const 0
+     i64.store
+     global.get $~lib/memory/__stack_pointer
+     i32.const 0
+     i32.store offset=8
+     global.get $~lib/memory/__stack_pointer
+     local.get $3
+     i32.load offset=4
+     local.get $3
+     i32.load offset=8
+     local.get $3
+     i32.load offset=12
+     call $assembly/SomaSolution/SomaSolution#constructor
+     local.tee $8
+     i32.store
+     global.get $~lib/memory/__stack_pointer
+     local.get $3
+     i32.load
+     local.tee $6
+     i32.store offset=4
+     global.get $~lib/memory/__stack_pointer
+     local.get $3
+     i32.load
+     local.tee $7
+     i32.store offset=8
+     local.get $8
+     local.get $6
+     local.get $7
+     i32.load offset=12
+     call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#slice
+     call $assembly/SomaSolver/SomaSolver#set:solutionCube
+     global.get $~lib/memory/__stack_pointer
+     i32.const 12
+     i32.add
+     global.set $~lib/memory/__stack_pointer
+     local.get $8
+     i32.store offset=12
+     local.get $11
+     local.get $9
+     call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+     local.set $5
+     global.get $~lib/memory/__stack_pointer
+     local.get $5
+     i32.store offset=4
+     local.get $8
+     local.get $5
+     call $assembly/SomaSolution/SomaSolution#addSpace
+     local.get $2
+     i32.load offset=12
+     i32.const 1
+     i32.eq
+     if
+      global.get $~lib/memory/__stack_pointer
+      local.get $0
+      i32.load offset=16
+      local.tee $1
+      i32.store offset=16
+      local.get $1
+      local.get $8
+      call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+      global.get $~lib/memory/__stack_pointer
+      local.get $0
+      i32.load offset=4
+      local.get $0
+      i32.load offset=8
+      local.get $0
+      i32.load offset=12
+      call $assembly/SomaSolution/SomaSolution#constructor
+      i32.store offset=20
+      global.get $~lib/memory/__stack_pointer
+      i32.const 28
+      i32.add
+      global.set $~lib/memory/__stack_pointer
+      return
+     else
+      global.get $~lib/memory/__stack_pointer
+      i32.const 4
+      i32.sub
+      global.set $~lib/memory/__stack_pointer
+      call $~stack_check
+      global.get $~lib/memory/__stack_pointer
+      i32.const 0
+      i32.store
+      i32.const 1
+      local.get $2
+      i32.load offset=12
+      local.tee $5
+      local.get $5
+      i32.const 1
+      i32.gt_s
+      select
+      local.set $7
+      global.get $~lib/memory/__stack_pointer
+      local.get $5
+      local.get $7
+      i32.sub
+      local.tee $5
+      i32.const 0
+      local.get $5
+      i32.const 0
+      i32.gt_s
+      select
+      local.tee $12
+      i32.const 13
+      i32.const 0
+      call $~lib/rt/__newArray
+      local.tee $6
+      i32.store
+      local.get $6
+      i32.load offset=4
+      local.set $14
+      local.get $2
+      i32.load offset=4
+      local.get $7
+      i32.const 2
+      i32.shl
+      i32.add
+      local.set $7
+      i32.const 0
+      local.set $5
+      local.get $12
+      i32.const 2
+      i32.shl
+      local.set $12
+      loop $while-continue|0
+       local.get $5
+       local.get $12
+       i32.lt_u
+       if
+        local.get $5
+        local.get $14
+        i32.add
+        local.get $5
+        local.get $7
+        i32.add
+        i32.load
+        local.tee $15
+        i32.store
+        local.get $6
+        local.get $15
+        i32.const 1
+        call $~lib/rt/itcms/__link
+        local.get $5
+        i32.const 4
+        i32.add
+        local.set $5
+        br $while-continue|0
+       end
+      end
+      global.get $~lib/memory/__stack_pointer
+      i32.const 4
+      i32.add
+      global.set $~lib/memory/__stack_pointer
+      global.get $~lib/memory/__stack_pointer
+      local.get $6
+      i32.store offset=24
+      local.get $0
+      local.get $10
+      local.get $6
+      local.get $8
+      local.get $4
+      i32.const 1
+      i32.add
+      call $assembly/SomaSolver/SomaSolver#backtrackSolve
+     end
+    end
+    local.get $9
+    i32.const 1
+    i32.add
+    local.set $9
+    br $for-loop|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 28
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#getAllRotations (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 12
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#constructor
+  local.tee $2
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#clone
+  local.tee $0
+  i32.store offset=4
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#concat
+  local.tee $2
+  i32.store
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Y
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#concat
+  local.tee $2
+  i32.store
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Y
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#concat
+  local.tee $2
+  i32.store
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Y
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#concat
+  local.tee $2
+  i32.store
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Z
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=8
+  local.get $2
+  local.get $1
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#concat
+  local.tee $1
+  i32.store
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Z
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#rot90Z
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  call $assembly/VoxelSpace/VoxelSpace#getXAxisSpins
+  local.set $0
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store offset=8
+  local.get $1
+  local.get $0
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#concat
+  local.tee $0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 12
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $0
+ )
+ (func $assembly/SomaSolution/SomaSolution#getRotations (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  (local $8 i32)
+  (local $9 i32)
+  (local $10 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 20
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store offset=16
+  global.get $~lib/memory/__stack_pointer
+  call $~lib/array/Array<assembly/SomaSolution/SomaSolution>#constructor
+  local.tee $6
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load
+  local.tee $2
+  i32.store offset=4
+  local.get $2
+  i32.load offset=12
+  i32.eqz
+  if
+   global.get $~lib/memory/__stack_pointer
+   i32.const 20
+   i32.add
+   global.set $~lib/memory/__stack_pointer
+   local.get $6
+   return
+  end
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load
+  local.tee $1
+  i32.store offset=4
+  global.get $~lib/memory/__stack_pointer
+  i32.const 1952
+  i32.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  global.get $~lib/memory/__stack_pointer
+  i32.const 12
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.load offset=12
+  local.tee $3
+  i32.const 13
+  i32.const 0
+  call $~lib/rt/__newArray
+  local.tee $2
+  i32.store
+  local.get $2
+  i32.load offset=4
+  local.set $9
+  loop $for-loop|0
+   local.get $4
+   local.get $3
+   local.get $1
+   i32.load offset=12
+   local.tee $5
+   local.get $3
+   local.get $5
+   i32.lt_s
+   select
+   i32.lt_s
+   if
+    global.get $~lib/memory/__stack_pointer
+    local.get $4
+    i32.const 2
+    i32.shl
+    local.tee $10
+    local.get $1
+    i32.load offset=4
+    i32.add
+    i32.load
+    local.tee $5
+    i32.store offset=4
+    global.get $~lib/memory/__stack_pointer
+    local.get $5
+    local.get $4
+    local.get $1
+    i32.const 1952
+    i32.load
+    call_indirect $0 (type $i32_i32_i32_=>_i32)
+    local.tee $5
+    i32.store offset=8
+    local.get $9
+    local.get $10
+    i32.add
+    local.get $5
+    i32.store
+    local.get $2
+    local.get $5
+    i32.const 1
+    call $~lib/rt/itcms/__link
+    local.get $4
+    i32.const 1
+    i32.add
+    local.set $4
+    br $for-loop|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 12
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $2
+  i32.store offset=12
+  loop $for-loop|00
+   local.get $2
+   i32.const 0
+   call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+   local.set $1
+   global.get $~lib/memory/__stack_pointer
+   local.get $1
+   i32.store offset=4
+   local.get $7
+   local.get $1
+   i32.load offset=12
+   i32.lt_s
+   if
+    global.get $~lib/memory/__stack_pointer
+    local.get $0
+    i32.load offset=4
+    local.get $0
+    i32.load offset=8
+    local.get $0
+    i32.load offset=12
+    call $assembly/SomaSolution/SomaSolution#constructor
+    local.tee $4
+    i32.store offset=16
+    i32.const 0
+    local.set $1
+    loop $for-loop|1
+     local.get $1
+     local.get $2
+     i32.load offset=12
+     i32.lt_s
+     if
+      local.get $2
+      local.get $1
+      call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+      local.set $3
+      global.get $~lib/memory/__stack_pointer
+      local.get $3
+      i32.store offset=8
+      local.get $3
+      local.get $7
+      call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+      local.set $3
+      global.get $~lib/memory/__stack_pointer
+      local.get $3
+      i32.store offset=8
+      local.get $4
+      local.get $3
+      call $assembly/SomaSolution/SomaSolution#addSpace
+      local.get $1
+      i32.const 1
+      i32.add
+      local.set $1
+      br $for-loop|1
+     end
+    end
+    local.get $6
+    local.get $4
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+    local.get $7
+    i32.const 1
+    i32.add
+    local.set $7
+    br $for-loop|00
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 20
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $6
+ )
+ (func $assembly/SomaSolution/SomaSolution.filterUnique (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  (local $8 i32)
+  (local $9 i32)
+  (local $10 i32)
+  (local $11 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 16
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  call $~lib/array/Array<assembly/SomaSolution/SomaSolution>#constructor
+  local.tee $3
+  i32.store
+  local.get $0
+  i32.load offset=12
+  i32.eqz
+  if
+   global.get $~lib/memory/__stack_pointer
+   i32.const 16
+   i32.add
+   global.set $~lib/memory/__stack_pointer
+   local.get $3
+   return
+  end
+  local.get $0
+  i32.const 0
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=4
+  local.get $3
+  local.get $1
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+  loop $for-loop|0
+   local.get $4
+   local.get $0
+   i32.load offset=12
+   i32.lt_s
+   if
+    global.get $~lib/memory/__stack_pointer
+    local.get $0
+    local.get $4
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+    local.set $1
+    global.get $~lib/memory/__stack_pointer
+    local.get $1
+    i32.store offset=8
+    local.get $1
+    call $assembly/SomaSolution/SomaSolution#getRotations
+    local.tee $9
+    i32.store offset=12
+    i32.const 0
+    local.set $1
+    i32.const 0
+    local.set $5
+    loop $for-loop|1
+     local.get $5
+     local.get $9
+     i32.load offset=12
+     i32.lt_s
+     if
+      local.get $3
+      i32.load offset=12
+      local.set $11
+      i32.const 0
+      local.set $6
+      loop $for-loop|2
+       local.get $6
+       local.get $11
+       i32.lt_s
+       if
+        local.get $9
+        local.get $5
+        call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+        local.set $8
+        global.get $~lib/memory/__stack_pointer
+        local.get $8
+        i32.store offset=8
+        local.get $3
+        local.get $6
+        call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+        local.set $10
+        global.get $~lib/memory/__stack_pointer
+        local.get $10
+        i32.store offset=4
+        i32.const 1
+        local.get $1
+        block $__inlined_func$assembly/SomaSolution/SomaSolution#matches (result i32)
+         i32.const 0
+         local.set $2
+         global.get $~lib/memory/__stack_pointer
+         i32.const 12
+         i32.sub
+         global.set $~lib/memory/__stack_pointer
+         call $~stack_check
+         global.get $~lib/memory/__stack_pointer
+         i64.const 0
+         i64.store
+         global.get $~lib/memory/__stack_pointer
+         i32.const 0
+         i32.store offset=8
+         loop $for-loop|00
+          global.get $~lib/memory/__stack_pointer
+          local.get $8
+          i32.load
+          local.tee $1
+          i32.store
+          local.get $2
+          local.get $1
+          i32.load offset=12
+          i32.lt_s
+          if
+           global.get $~lib/memory/__stack_pointer
+           local.get $8
+           i32.load
+           local.tee $1
+           i32.store offset=8
+           local.get $1
+           local.get $2
+           call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+           local.set $1
+           global.get $~lib/memory/__stack_pointer
+           local.get $1
+           i32.store
+           global.get $~lib/memory/__stack_pointer
+           local.get $10
+           i32.load
+           local.tee $7
+           i32.store offset=8
+           local.get $7
+           local.get $2
+           call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+           local.set $7
+           global.get $~lib/memory/__stack_pointer
+           local.get $7
+           i32.store offset=4
+           local.get $1
+           local.get $7
+           call $assembly/VoxelSpace/VoxelSpace#matches
+           i32.eqz
+           if
+            global.get $~lib/memory/__stack_pointer
+            i32.const 12
+            i32.add
+            global.set $~lib/memory/__stack_pointer
+            i32.const 0
+            br $__inlined_func$assembly/SomaSolution/SomaSolution#matches
+           end
+           local.get $2
+           i32.const 1
+           i32.add
+           local.set $2
+           br $for-loop|00
+          end
+         end
+         global.get $~lib/memory/__stack_pointer
+         i32.const 12
+         i32.add
+         global.set $~lib/memory/__stack_pointer
+         i32.const 1
+        end
+        select
+        local.set $1
+        local.get $6
+        i32.const 1
+        i32.add
+        local.set $6
+        br $for-loop|2
+       end
+      end
+      local.get $5
+      i32.const 1
+      i32.add
+      local.set $5
+      br $for-loop|1
+     end
+    end
+    local.get $1
+    i32.eqz
+    if
+     local.get $0
+     local.get $4
+     call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+     local.set $1
+     global.get $~lib/memory/__stack_pointer
+     local.get $1
+     i32.store offset=4
+     local.get $3
+     local.get $1
+     call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+    end
+    local.get $4
+    i32.const 1
+    i32.add
+    local.set $4
+    br $for-loop|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 16
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $3
+ )
+ (func $assembly/SomaSolver/SomaSolver#solve (param $0 i32) (param $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  (local $8 i32)
+  (local $9 i32)
+  (local $10 i32)
+  (local $11 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 20
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store offset=16
+  local.get $1
+  i32.load offset=12
+  i32.eqz
+  if
+   i32.const 1552
+   i32.const 1696
+   i32.const 19
+   i32.const 13
+   call $~lib/builtins/abort
+   unreachable
+  end
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load offset=16
+  local.tee $2
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load offset=16
+  local.tee $3
+  i32.store offset=4
+  local.get $2
+  local.get $3
+  i32.load offset=12
+  call $~lib/array/Array<assembly/SomaSolution/SomaSolution>#splice
+  global.get $~lib/memory/__stack_pointer
+  call $~lib/array/Array<~lib/array/Array<assembly/VoxelSpace/VoxelSpace>>#constructor
+  local.tee $6
+  i32.store offset=8
+  i32.const 1
+  local.set $2
+  loop $for-loop|0
+   local.get $2
+   local.get $1
+   i32.load offset=12
+   i32.lt_s
+   if
+    local.get $1
+    local.get $2
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+    local.set $4
+    global.get $~lib/memory/__stack_pointer
+    local.get $4
+    i32.store offset=4
+    local.get $0
+    i32.load offset=4
+    local.set $8
+    local.get $0
+    i32.load offset=8
+    local.set $9
+    local.get $0
+    i32.load offset=12
+    local.set $10
+    i32.const 0
+    local.set $3
+    global.get $~lib/memory/__stack_pointer
+    i32.const 12
+    i32.sub
+    global.set $~lib/memory/__stack_pointer
+    call $~stack_check
+    global.get $~lib/memory/__stack_pointer
+    i64.const 0
+    i64.store
+    global.get $~lib/memory/__stack_pointer
+    i32.const 0
+    i32.store offset=8
+    global.get $~lib/memory/__stack_pointer
+    local.get $4
+    call $assembly/VoxelSpace/VoxelSpace#getUniqueRotations
+    local.tee $7
+    i32.store
+    global.get $~lib/memory/__stack_pointer
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#constructor
+    local.tee $4
+    i32.store offset=4
+    loop $for-loop|00
+     local.get $3
+     local.get $7
+     i32.load offset=12
+     i32.lt_s
+     if
+      global.get $~lib/memory/__stack_pointer
+      local.get $7
+      local.get $3
+      call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+      local.set $5
+      global.get $~lib/memory/__stack_pointer
+      local.get $5
+      i32.store offset=8
+      local.get $5
+      local.get $8
+      local.get $9
+      local.get $10
+      call $assembly/VoxelSpace/VoxelSpace#getAllPositionsInPrism
+      local.set $5
+      global.get $~lib/memory/__stack_pointer
+      local.get $5
+      i32.store offset=8
+      local.get $4
+      local.get $5
+      call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#concat
+      local.tee $4
+      i32.store offset=4
+      local.get $3
+      i32.const 1
+      i32.add
+      local.set $3
+      br $for-loop|00
+     end
+    end
+    global.get $~lib/memory/__stack_pointer
+    i32.const 12
+    i32.add
+    global.set $~lib/memory/__stack_pointer
+    global.get $~lib/memory/__stack_pointer
+    local.get $4
+    i32.store offset=4
+    local.get $6
+    local.get $4
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+    local.get $2
+    i32.const 1
+    i32.add
+    local.set $2
+    br $for-loop|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  call $~lib/array/Array<~lib/array/Array<assembly/VoxelSpace/VoxelSpace>>#constructor
+  local.tee $2
+  i32.store offset=12
+  local.get $1
+  i32.const 0
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=4
+  local.get $1
+  local.get $0
+  i32.load offset=4
+  local.get $0
+  i32.load offset=8
+  local.get $0
+  i32.load offset=12
+  call $assembly/VoxelSpace/VoxelSpace#getAllPositionsInPrism
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=4
+  local.get $2
+  local.get $1
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+  global.get $~lib/memory/__stack_pointer
+  local.get $2
+  local.get $6
+  call $~lib/array/Array<~lib/array/Array<assembly/VoxelSpace/VoxelSpace>>#concat
+  local.tee $2
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load
+  local.tee $3
+  i32.store offset=4
+  local.get $0
+  i32.load offset=4
+  local.get $0
+  i32.load offset=8
+  local.get $0
+  i32.load offset=12
+  call $assembly/SomaSolution/SomaSolution#constructor
+  local.set $1
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=16
+  local.get $0
+  local.get $3
+  local.get $2
+  local.get $1
+  i32.const 0
+  call $assembly/SomaSolver/SomaSolver#backtrackSolve
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load offset=16
+  local.tee $1
+  i32.store
+  local.get $0
+  local.get $1
+  call $assembly/SomaSolution/SomaSolution.filterUnique
+  call $assembly/SomaSolver/SomaSolver#set:solutions
+  global.get $~lib/memory/__stack_pointer
+  i32.const 20
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $assembly/index/solve (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  (local $8 i32)
+  (local $9 i64)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 28
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store offset=8
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store offset=16
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store offset=24
+  global.get $~lib/memory/__stack_pointer
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 20
+  i32.const 6
+  call $~lib/rt/itcms/__new
+  local.tee $4
+  i32.store
+  local.get $4
+  i32.const 0
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $4
+  i32.const 0
+  i32.store offset=4
+  local.get $4
+  i32.const 0
+  i32.store offset=8
+  local.get $4
+  i32.const 0
+  i32.store offset=12
+  local.get $4
+  call $~lib/array/Array<assembly/SomaSolution/SomaSolution>#constructor
+  call $assembly/SomaSolver/SomaSolver#set:solutions
+  local.get $4
+  local.get $1
+  i32.store offset=4
+  local.get $4
+  local.get $2
+  i32.store offset=8
+  local.get $4
+  local.get $3
+  i32.store offset=12
+  local.get $4
+  i32.const 0
+  local.get $1
+  local.get $2
+  local.get $3
+  i64.const 0
+  i32.const 0
+  call $assembly/VoxelSpace/VoxelSpace#constructor
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $4
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#constructor
+  local.tee $6
+  i32.store offset=4
+  loop $for-loop|0
+   local.get $5
+   local.get $0
+   i32.load offset=12
+   i32.lt_s
+   if
+    local.get $5
+    local.get $0
+    i32.load offset=12
+    i32.ge_u
+    if
+     i32.const 1248
+     i32.const 1504
+     i32.const 99
+     i32.const 42
+     call $~lib/builtins/abort
+     unreachable
+    end
+    local.get $5
+    local.get $1
+    local.get $2
+    local.get $3
+    local.get $0
+    i32.load offset=4
+    local.get $5
+    i32.const 3
+    i32.shl
+    i32.add
+    i64.load
+    i32.const 1
+    call $assembly/VoxelSpace/VoxelSpace#constructor
+    local.set $8
+    global.get $~lib/memory/__stack_pointer
+    local.get $8
+    i32.store offset=8
+    local.get $6
+    local.get $8
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+    local.get $5
+    i32.const 1
+    i32.add
+    local.set $5
+    br $for-loop|0
+   end
+  end
+  local.get $4
+  local.get $6
+  call $assembly/SomaSolver/SomaSolver#solve
+  global.get $~lib/memory/__stack_pointer
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $4
+  i32.load offset=16
+  local.tee $1
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $4
+  i32.load offset=16
+  local.tee $2
+  i32.store offset=4
+  local.get $1
+  local.get $2
+  i32.load offset=12
+  call $~lib/array/Array<assembly/SomaSolution/SomaSolution>#slice
+  local.set $2
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $2
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 16
+  i32.const 5
+  call $~lib/rt/itcms/__new
+  local.tee $1
+  i32.store
+  local.get $1
+  i32.const 0
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $1
+  i32.const 0
+  i32.store offset=4
+  local.get $1
+  i32.const 0
+  i32.store offset=8
+  local.get $1
+  i32.const 0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 32
+  i32.const 0
+  call $~lib/rt/itcms/__new
+  local.tee $0
+  i32.store offset=4
+  local.get $0
+  i32.const 32
+  call $~lib/memory/memory.fill
+  local.get $1
+  local.get $0
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $1
+  local.get $0
+  i32.store offset=4
+  local.get $1
+  i32.const 32
+  i32.store offset=8
+  local.get $1
+  i32.const 0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store offset=16
+  loop $for-loop|1
+   local.get $7
+   local.get $2
+   i32.load offset=12
+   i32.lt_s
+   if
+    global.get $~lib/memory/__stack_pointer
+    local.get $2
+    local.get $7
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+    local.set $0
+    global.get $~lib/memory/__stack_pointer
+    local.get $0
+    i32.store offset=20
+    local.get $0
+    i32.load
+    local.tee $3
+    i32.store offset=24
+    local.get $3
+    i32.load offset=12
+    local.set $4
+    global.get $~lib/memory/__stack_pointer
+    i32.const 4
+    i32.sub
+    global.set $~lib/memory/__stack_pointer
+    call $~stack_check
+    global.get $~lib/memory/__stack_pointer
+    i32.const 0
+    i32.store
+    global.get $~lib/memory/__stack_pointer
+    i32.const 12
+    i32.const 4
+    call $~lib/rt/itcms/__new
+    local.tee $0
+    i32.store
+    global.get $~lib/memory/__stack_pointer
+    global.get $~lib/memory/__stack_pointer
+    i32.const 8
+    i32.sub
+    global.set $~lib/memory/__stack_pointer
+    call $~stack_check
+    global.get $~lib/memory/__stack_pointer
+    i64.const 0
+    i64.store
+    local.get $0
+    i32.eqz
+    if
+     global.get $~lib/memory/__stack_pointer
+     i32.const 12
+     i32.const 2
+     call $~lib/rt/itcms/__new
+     local.tee $0
+     i32.store
+    end
+    local.get $0
+    i32.const 0
+    call $assembly/SomaSolver/SomaSolver#set:solutionCube
+    local.get $0
+    i32.const 0
+    i32.store offset=4
+    local.get $0
+    i32.const 0
+    i32.store offset=8
+    local.get $4
+    i32.const 134217727
+    i32.gt_u
+    if
+     i32.const 1456
+     i32.const 1984
+     i32.const 18
+     i32.const 57
+     call $~lib/builtins/abort
+     unreachable
+    end
+    global.get $~lib/memory/__stack_pointer
+    local.get $4
+    i32.const 3
+    i32.shl
+    local.tee $5
+    i32.const 0
+    call $~lib/rt/itcms/__new
+    local.tee $4
+    i32.store offset=4
+    local.get $4
+    local.get $5
+    call $~lib/memory/memory.fill
+    local.get $0
+    local.get $4
+    call $assembly/SomaSolver/SomaSolver#set:solutionCube
+    local.get $0
+    local.get $4
+    i32.store offset=4
+    local.get $0
+    local.get $5
+    i32.store offset=8
+    global.get $~lib/memory/__stack_pointer
+    i32.const 8
+    i32.add
+    global.set $~lib/memory/__stack_pointer
+    local.get $0
+    i32.store
+    global.get $~lib/memory/__stack_pointer
+    i32.const 4
+    i32.add
+    global.set $~lib/memory/__stack_pointer
+    global.get $~lib/memory/__stack_pointer
+    local.get $0
+    i32.store offset=8
+    local.get $1
+    local.get $0
+    call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+    i32.const 0
+    local.set $0
+    loop $for-loop|2
+     local.get $0
+     local.get $3
+     i32.load offset=12
+     i32.lt_s
+     if
+      local.get $1
+      local.get $7
+      call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+      local.set $4
+      global.get $~lib/memory/__stack_pointer
+      local.get $4
+      i32.store offset=20
+      local.get $3
+      local.get $0
+      call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get
+      local.set $5
+      global.get $~lib/memory/__stack_pointer
+      local.get $5
+      i32.store offset=8
+      local.get $5
+      i64.load offset=8
+      local.set $9
+      local.get $0
+      local.get $4
+      i32.load offset=8
+      i32.const 3
+      i32.shr_u
+      i32.ge_u
+      if
+       i32.const 1248
+       i32.const 2048
+       i32.const 980
+       i32.const 64
+       call $~lib/builtins/abort
+       unreachable
+      end
+      local.get $4
+      i32.load offset=4
+      local.get $0
+      i32.const 3
+      i32.shl
+      i32.add
+      local.get $9
+      i64.store
+      local.get $0
+      i32.const 1
+      i32.add
+      local.set $0
+      br $for-loop|2
+     end
+    end
+    local.get $7
+    i32.const 1
+    i32.add
+    local.set $7
+    br $for-loop|1
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 28
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $1
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#getExtrema (param $0 i32) (result i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load offset=20
+  local.set $3
+  local.get $0
+  i32.load offset=24
+  local.set $5
+  local.get $0
+  i32.load offset=28
+  local.set $6
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 24
+  i32.const 11
+  call $~lib/rt/itcms/__new
+  local.tee $1
+  i32.store
+  local.get $1
+  i32.const 0
+  i32.store
+  local.get $1
+  local.get $3
+  i32.store offset=4
+  local.get $1
+  i32.const 0
+  i32.store offset=8
+  local.get $1
+  local.get $5
+  i32.store offset=12
+  local.get $1
+  i32.const 0
+  i32.store offset=16
+  local.get $1
+  local.get $6
+  i32.store offset=20
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $1
+  i32.store
+  loop $for-loop|0
+   local.get $4
+   local.get $0
+   i32.load offset=20
+   i32.lt_s
+   if
+    i32.const 0
+    local.set $2
+    loop $for-loop|1
+     local.get $2
+     local.get $0
+     i32.load offset=24
+     i32.lt_s
+     if
+      i32.const 0
+      local.set $3
+      loop $for-loop|2
+       local.get $3
+       local.get $0
+       i32.load offset=28
+       i32.lt_s
+       if
+        local.get $0
+        local.get $4
+        local.get $2
+        local.get $3
+        call $assembly/VoxelSpace/VoxelSpace#at
+        if
+         local.get $1
+         local.get $1
+         i32.load
+         f64.convert_i32_s
+         local.get $4
+         f64.convert_i32_s
+         f64.max
+         i32.trunc_f64_s
+         i32.store
+         local.get $1
+         local.get $1
+         i32.load offset=4
+         f64.convert_i32_s
+         local.get $4
+         f64.convert_i32_s
+         f64.min
+         i32.trunc_f64_s
+         i32.store offset=4
+         local.get $1
+         local.get $1
+         i32.load offset=8
+         f64.convert_i32_s
+         local.get $2
+         f64.convert_i32_s
+         f64.max
+         i32.trunc_f64_s
+         i32.store offset=8
+         local.get $1
+         local.get $1
+         i32.load offset=12
+         f64.convert_i32_s
+         local.get $2
+         f64.convert_i32_s
+         f64.min
+         i32.trunc_f64_s
+         i32.store offset=12
+         local.get $1
+         local.get $1
+         i32.load offset=16
+         f64.convert_i32_s
+         local.get $3
+         f64.convert_i32_s
+         f64.max
+         i32.trunc_f64_s
+         i32.store offset=16
+         local.get $1
+         local.get $1
+         i32.load offset=20
+         f64.convert_i32_s
+         local.get $3
+         f64.convert_i32_s
+         f64.min
+         i32.trunc_f64_s
+         i32.store offset=20
+        end
+        local.get $3
+        i32.const 1
+        i32.add
+        local.set $3
+        br $for-loop|2
+       end
+      end
+      local.get $2
+      i32.const 1
+      i32.add
+      local.set $2
+      br $for-loop|1
+     end
+    end
+    local.get $4
+    i32.const 1
+    i32.add
+    local.set $4
+    br $for-loop|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $1
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#constructor (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) (param $5 i32) (result i32)
+  (local $6 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 32
+  i32.const 7
+  call $~lib/rt/itcms/__new
+  local.tee $6
+  i32.store
+  local.get $6
+  i32.const 0
+  i32.store
+  local.get $6
+  i64.const 0
+  i64.store offset=8
+  local.get $6
+  i32.const 0
+  i32.store offset=16
+  local.get $6
+  i32.const 0
+  i32.store offset=20
+  local.get $6
+  i32.const 0
+  i32.store offset=24
+  local.get $6
+  i32.const 0
+  i32.store offset=28
+  local.get $6
+  local.get $0
+  i32.store offset=16
+  local.get $6
+  local.get $3
+  local.get $1
+  local.get $2
+  i32.mul
+  i32.mul
+  i32.store
+  local.get $6
+  local.get $1
+  i32.store offset=20
+  local.get $6
+  local.get $2
+  i32.store offset=24
+  local.get $6
+  local.get $3
+  i32.store offset=28
+  local.get $6
+  local.get $4
+  i64.store offset=8
+  local.get $5
+  if
+   local.get $6
+   call $assembly/VoxelSpace/VoxelSpace#cullEmptySpace
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $6
+ )
+ (func $~lib/array/Array<assembly/SomaSolution/SomaSolution>#constructor (result i32)
+  (local $0 i32)
+  (local $1 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 16
+  i32.const 10
+  call $~lib/rt/itcms/__new
+  local.tee $0
+  i32.store
+  local.get $0
+  i32.const 0
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $0
+  i32.const 0
+  i32.store offset=4
+  local.get $0
+  i32.const 0
+  i32.store offset=8
+  local.get $0
+  i32.const 0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 32
+  i32.const 0
+  call $~lib/rt/itcms/__new
+  local.tee $1
+  i32.store offset=4
+  local.get $1
+  i32.const 32
+  call $~lib/memory/memory.fill
+  local.get $0
+  local.get $1
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $0
+  local.get $1
+  i32.store offset=4
+  local.get $0
+  i32.const 32
+  i32.store offset=8
+  local.get $0
+  i32.const 0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $0
+ )
+ (func $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#constructor (result i32)
+  (local $0 i32)
+  (local $1 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 16
+  i32.const 9
+  call $~lib/rt/itcms/__new
+  local.tee $0
+  i32.store
+  local.get $0
+  i32.const 0
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $0
+  i32.const 0
+  i32.store offset=4
+  local.get $0
+  i32.const 0
+  i32.store offset=8
+  local.get $0
+  i32.const 0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 32
+  i32.const 0
+  call $~lib/rt/itcms/__new
+  local.tee $1
+  i32.store offset=4
+  local.get $1
+  i32.const 32
+  call $~lib/memory/memory.fill
+  local.get $0
+  local.get $1
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $0
+  local.get $1
+  i32.store offset=4
+  local.get $0
+  i32.const 32
+  i32.store offset=8
+  local.get $0
+  i32.const 0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $0
+ )
+ (func $~lib/rt/__newArray (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.const 2
+  i32.shl
+  local.tee $4
+  i32.const 0
+  call $~lib/rt/itcms/__new
+  local.set $3
+  local.get $2
+  if
+   local.get $3
+   local.get $2
+   local.get $4
+   call $~lib/memory/memory.copy
+  end
+  local.get $3
+  i32.store
+  i32.const 16
+  local.get $1
+  call $~lib/rt/itcms/__new
+  local.tee $1
+  local.get $3
+  i32.store
+  local.get $1
+  local.get $3
+  i32.const 0
+  call $~lib/rt/itcms/__link
+  local.get $1
+  local.get $3
+  i32.store offset=4
+  local.get $1
+  local.get $4
+  i32.store offset=8
+  local.get $1
+  local.get $0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $1
+ )
+ (func $~lib/array/Array<assembly/SomaSolution/SomaSolution>#splice (param $0 i32) (param $1 i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  i32.const 0
+  local.get $0
+  i32.load offset=12
+  local.tee $3
+  local.get $3
+  i32.const 0
+  i32.gt_s
+  select
+  local.set $2
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  local.get $3
+  local.get $2
+  i32.sub
+  local.tee $4
+  local.get $1
+  local.get $4
+  i32.lt_s
+  select
+  local.tee $1
+  i32.const 0
+  local.get $1
+  i32.const 0
+  i32.gt_s
+  select
+  local.tee $1
+  i32.const 10
+  i32.const 0
+  call $~lib/rt/__newArray
+  local.tee $4
+  i32.store
+  local.get $4
+  i32.load offset=4
+  local.get $0
+  i32.load offset=4
+  local.tee $4
+  local.get $2
+  i32.const 2
+  i32.shl
+  i32.add
+  local.tee $5
+  local.get $1
+  i32.const 2
+  i32.shl
+  call $~lib/memory/memory.copy
+  local.get $3
+  local.get $1
+  local.get $2
+  i32.add
+  local.tee $2
+  i32.ne
+  if
+   local.get $5
+   local.get $4
+   local.get $2
+   i32.const 2
+   i32.shl
+   i32.add
+   local.get $3
+   local.get $2
+   i32.sub
+   i32.const 2
+   i32.shl
+   call $~lib/memory/memory.copy
+  end
+  local.get $0
+  local.get $3
+  local.get $1
+  i32.sub
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ (func $~lib/array/Array<~lib/array/Array<assembly/VoxelSpace/VoxelSpace>>#constructor (result i32)
+  (local $0 i32)
+  (local $1 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 16
+  i32.const 13
+  call $~lib/rt/itcms/__new
+  local.tee $0
+  i32.store
+  local.get $0
+  i32.const 0
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $0
+  i32.const 0
+  i32.store offset=4
+  local.get $0
+  i32.const 0
+  i32.store offset=8
+  local.get $0
+  i32.const 0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 32
+  i32.const 0
+  call $~lib/rt/itcms/__new
+  local.tee $1
+  i32.store offset=4
+  local.get $1
+  i32.const 32
+  call $~lib/memory/memory.fill
+  local.get $0
+  local.get $1
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $0
+  local.get $1
+  i32.store offset=4
+  local.get $0
+  i32.const 32
+  i32.store offset=8
+  local.get $0
+  i32.const 0
+  i32.store offset=12
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $0
+ )
+ (func $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#__get (param $0 i32) (param $1 i32) (result i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  local.get $1
+  local.get $0
+  i32.load offset=12
+  i32.ge_u
+  if
+   i32.const 1248
+   i32.const 1504
+   i32.const 99
+   i32.const 42
+   call $~lib/builtins/abort
+   unreachable
+  end
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.load offset=4
+  local.get $1
+  i32.const 2
+  i32.shl
+  i32.add
+  i32.load
+  local.tee $0
+  i32.store
+  local.get $0
+  i32.eqz
+  if
+   i32.const 1760
+   i32.const 1504
+   i32.const 103
+   i32.const 40
+   call $~lib/builtins/abort
+   unreachable
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $0
+ )
+ (func $assembly/VoxelSpace/VoxelSpace#getAllPositionsInPrism (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  (local $8 i32)
+  (local $9 i32)
+  (local $10 i32)
+  (local $11 i32)
+  (local $12 i32)
+  (local $13 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i64.const 0
+  i64.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.const 9
+  i32.const 1888
+  call $~lib/rt/__newArray
+  local.tee $10
+  i32.store
+  local.get $1
+  local.get $0
+  i32.load offset=20
+  i32.lt_s
+  if (result i32)
+   i32.const 1
+  else
+   local.get $2
+   local.get $0
+   i32.load offset=24
+   i32.lt_s
+  end
+  if (result i32)
+   i32.const 1
+  else
+   local.get $3
+   local.get $0
+   i32.load offset=28
+   i32.lt_s
+  end
+  if
+   global.get $~lib/memory/__stack_pointer
+   i32.const 8
+   i32.add
+   global.set $~lib/memory/__stack_pointer
+   local.get $10
+   return
+  end
+  loop $for-loop|0
+   local.get $11
+   local.get $1
+   local.get $0
+   i32.load offset=20
+   i32.sub
+   i32.const 1
+   i32.add
+   i32.lt_s
+   if
+    i32.const 0
+    local.set $8
+    loop $for-loop|1
+     local.get $8
+     local.get $2
+     local.get $0
+     i32.load offset=24
+     i32.sub
+     i32.const 1
+     i32.add
+     i32.lt_s
+     if
+      i32.const 0
+      local.set $9
+      loop $for-loop|2
+       local.get $9
+       local.get $3
+       local.get $0
+       i32.load offset=28
+       i32.sub
+       i32.const 1
+       i32.add
+       i32.lt_s
+       if
+        global.get $~lib/memory/__stack_pointer
+        local.get $0
+        i32.load offset=16
+        local.get $1
+        local.get $2
+        local.get $3
+        i64.const 0
+        i32.const 0
+        call $assembly/VoxelSpace/VoxelSpace#constructor
+        local.tee $4
+        i32.store offset=4
+        i32.const 0
+        local.set $5
+        loop $for-loop|3
+         local.get $5
+         local.get $0
+         i32.load offset=20
+         i32.lt_s
+         if
+          i32.const 0
+          local.set $6
+          loop $for-loop|4
+           local.get $6
+           local.get $0
+           i32.load offset=24
+           i32.lt_s
+           if
+            i32.const 0
+            local.set $7
+            loop $for-loop|5
+             local.get $7
+             local.get $0
+             i32.load offset=28
+             i32.lt_s
+             if
+              local.get $0
+              local.get $5
+              local.get $6
+              local.get $7
+              call $assembly/VoxelSpace/VoxelSpace#at
+              i32.const 1
+              local.get $7
+              local.get $9
+              i32.add
+              local.get $5
+              local.get $11
+              i32.add
+              local.get $4
+              i32.load offset=24
+              local.get $4
+              i32.load offset=28
+              i32.mul
+              i32.mul
+              local.get $4
+              i32.load offset=28
+              local.get $6
+              local.get $8
+              i32.add
+              i32.mul
+              i32.add
+              i32.add
+              i32.shl
+              local.set $12
+              if
+               local.get $4
+               local.get $4
+               i64.load offset=8
+               local.get $12
+               i64.extend_i32_s
+               i64.or
+               i64.store offset=8
+              else
+               local.get $4
+               local.get $4
+               i64.load offset=8
+               local.get $12
+               i32.const -1
+               i32.xor
+               i64.extend_i32_s
+               i64.and
+               i64.store offset=8
+              end
+              local.get $7
+              i32.const 1
+              i32.add
+              local.set $7
+              br $for-loop|5
+             end
+            end
+            local.get $6
+            i32.const 1
+            i32.add
+            local.set $6
+            br $for-loop|4
+           end
+          end
+          local.get $5
+          i32.const 1
+          i32.add
+          local.set $5
+          br $for-loop|3
+         end
+        end
+        local.get $10
+        local.get $4
+        call $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#push
+        local.get $9
+        i32.const 1
+        i32.add
+        local.set $9
+        br $for-loop|2
+       end
+      end
+      local.get $8
+      i32.const 1
+      i32.add
+      local.set $8
+      br $for-loop|1
+     end
+    end
+    local.get $11
+    i32.const 1
+    i32.add
+    local.set $11
+    br $for-loop|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 8
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $10
+ )
+ (func $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#concat (param $0 i32) (param $1 i32) (result i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  local.get $0
+  i32.load offset=12
+  local.tee $2
+  local.get $1
+  i32.load offset=12
+  i32.const 0
+  local.get $1
+  select
+  local.tee $6
+  i32.add
+  local.tee $3
+  i32.const 268435455
+  i32.gt_u
+  if
+   i32.const 1456
+   i32.const 1504
+   i32.const 229
+   i32.const 60
+   call $~lib/builtins/abort
+   unreachable
+  end
+  global.get $~lib/memory/__stack_pointer
+  local.get $3
+  i32.const 9
+  i32.const 0
+  call $~lib/rt/__newArray
+  local.tee $3
+  i32.store
+  local.get $3
+  i32.load offset=4
+  local.set $5
+  local.get $2
+  i32.const 2
+  i32.shl
+  local.set $2
+  local.get $0
+  i32.load offset=4
+  local.set $0
+  loop $for-loop|0
+   local.get $2
+   local.get $4
+   i32.gt_u
+   if
+    local.get $4
+    local.get $5
+    i32.add
+    local.get $0
+    local.get $4
+    i32.add
+    i32.load
+    local.tee $7
+    i32.store
+    local.get $3
+    local.get $7
+    i32.const 1
+    call $~lib/rt/itcms/__link
+    local.get $4
+    i32.const 4
+    i32.add
+    local.set $4
+    br $for-loop|0
+   end
+  end
+  local.get $2
+  local.get $5
+  i32.add
+  local.set $4
+  local.get $1
+  i32.load offset=4
+  local.set $1
+  local.get $6
+  i32.const 2
+  i32.shl
+  local.set $5
+  i32.const 0
+  local.set $0
+  loop $for-loop|1
+   local.get $0
+   local.get $5
+   i32.lt_u
+   if
+    local.get $0
+    local.get $4
+    i32.add
+    local.get $0
+    local.get $1
+    i32.add
+    i32.load
+    local.tee $2
+    i32.store
+    local.get $3
+    local.get $2
+    i32.const 1
+    call $~lib/rt/itcms/__link
+    local.get $0
+    i32.const 4
+    i32.add
+    local.set $0
+    br $for-loop|1
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $3
+ )
+ (func $~lib/array/Array<~lib/array/Array<assembly/VoxelSpace/VoxelSpace>>#concat (param $0 i32) (param $1 i32) (result i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  (local $6 i32)
+  (local $7 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  local.get $0
+  i32.load offset=12
+  local.tee $2
+  local.get $1
+  i32.load offset=12
+  i32.const 0
+  local.get $1
+  select
+  local.tee $6
+  i32.add
+  local.tee $3
+  i32.const 268435455
+  i32.gt_u
+  if
+   i32.const 1456
+   i32.const 1504
+   i32.const 229
+   i32.const 60
+   call $~lib/builtins/abort
+   unreachable
+  end
+  global.get $~lib/memory/__stack_pointer
+  local.get $3
+  i32.const 13
+  i32.const 0
+  call $~lib/rt/__newArray
+  local.tee $3
+  i32.store
+  local.get $3
+  i32.load offset=4
+  local.set $5
+  local.get $2
+  i32.const 2
+  i32.shl
+  local.set $2
+  local.get $0
+  i32.load offset=4
+  local.set $0
+  loop $for-loop|0
+   local.get $2
+   local.get $4
+   i32.gt_u
+   if
+    local.get $4
+    local.get $5
+    i32.add
+    local.get $0
+    local.get $4
+    i32.add
+    i32.load
+    local.tee $7
+    i32.store
+    local.get $3
+    local.get $7
+    i32.const 1
+    call $~lib/rt/itcms/__link
+    local.get $4
+    i32.const 4
+    i32.add
+    local.set $4
+    br $for-loop|0
+   end
+  end
+  local.get $2
+  local.get $5
+  i32.add
+  local.set $4
+  local.get $1
+  i32.load offset=4
+  local.set $1
+  local.get $6
+  i32.const 2
+  i32.shl
+  local.set $5
+  i32.const 0
+  local.set $0
+  loop $for-loop|1
+   local.get $0
+   local.get $5
+   i32.lt_u
+   if
+    local.get $0
+    local.get $4
+    i32.add
+    local.get $0
+    local.get $1
+    i32.add
+    i32.load
+    local.tee $2
+    i32.store
+    local.get $3
+    local.get $2
+    i32.const 1
+    call $~lib/rt/itcms/__link
+    local.get $0
+    i32.const 4
+    i32.add
+    local.set $0
+    br $for-loop|1
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $3
+ )
+ (func $assembly/SomaSolution/SomaSolution#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+  (local $3 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  global.get $~lib/memory/__stack_pointer
+  i32.const 16
+  i32.const 8
+  call $~lib/rt/itcms/__new
+  local.tee $3
+  i32.store
+  local.get $3
+  i32.const 0
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  local.get $3
+  i32.const 0
+  i32.store offset=4
+  local.get $3
+  i32.const 0
+  i32.store offset=8
+  local.get $3
+  i32.const 0
+  i32.store offset=12
+  local.get $3
+  local.get $0
+  i32.store offset=4
+  local.get $3
+  local.get $1
+  i32.store offset=8
+  local.get $3
+  local.get $2
+  i32.store offset=12
+  local.get $3
+  i32.const 0
+  i32.const 9
+  i32.const 1920
+  call $~lib/rt/__newArray
+  call $assembly/SomaSolver/SomaSolver#set:solutionCube
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $3
+ )
+ (func $~lib/array/Array<assembly/VoxelSpace/VoxelSpace>#slice (param $0 i32) (param $1 i32) (result i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  i32.const 0
+  local.get $0
+  i32.load offset=12
+  local.tee $2
+  local.get $2
+  i32.const 0
+  i32.gt_s
+  select
+  local.set $3
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.const 0
+  i32.lt_s
+  if (result i32)
+   local.get $1
+   local.get $2
+   i32.add
+   local.tee $1
+   i32.const 0
+   local.get $1
+   i32.const 0
+   i32.gt_s
+   select
+  else
+   local.get $1
+   local.get $2
+   local.get $1
+   local.get $2
+   i32.lt_s
+   select
+  end
+  local.get $3
+  i32.sub
+  local.tee $1
+  i32.const 0
+  local.get $1
+  i32.const 0
+  i32.gt_s
+  select
+  local.tee $2
+  i32.const 9
+  i32.const 0
+  call $~lib/rt/__newArray
+  local.tee $1
+  i32.store
+  local.get $1
+  i32.load offset=4
+  local.set $4
+  local.get $0
+  i32.load offset=4
+  local.get $3
+  i32.const 2
+  i32.shl
+  i32.add
+  local.set $3
+  i32.const 0
+  local.set $0
+  local.get $2
+  i32.const 2
+  i32.shl
+  local.set $2
+  loop $while-continue|0
+   local.get $0
+   local.get $2
+   i32.lt_u
+   if
+    local.get $0
+    local.get $4
+    i32.add
+    local.get $0
+    local.get $3
+    i32.add
+    i32.load
+    local.tee $5
+    i32.store
+    local.get $1
+    local.get $5
+    i32.const 1
+    call $~lib/rt/itcms/__link
+    local.get $0
+    i32.const 4
+    i32.add
+    local.set $0
+    br $while-continue|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $1
+ )
+ (func $~lib/array/Array<assembly/SomaSolution/SomaSolution>#slice (param $0 i32) (param $1 i32) (result i32)
+  (local $2 i32)
+  (local $3 i32)
+  (local $4 i32)
+  (local $5 i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  i32.const 0
+  i32.store
+  i32.const 0
+  local.get $0
+  i32.load offset=12
+  local.tee $2
+  local.get $2
+  i32.const 0
+  i32.gt_s
+  select
+  local.set $3
+  global.get $~lib/memory/__stack_pointer
+  local.get $1
+  i32.const 0
+  i32.lt_s
+  if (result i32)
+   local.get $1
+   local.get $2
+   i32.add
+   local.tee $1
+   i32.const 0
+   local.get $1
+   i32.const 0
+   i32.gt_s
+   select
+  else
+   local.get $1
+   local.get $2
+   local.get $1
+   local.get $2
+   i32.lt_s
+   select
+  end
+  local.get $3
+  i32.sub
+  local.tee $1
+  i32.const 0
+  local.get $1
+  i32.const 0
+  i32.gt_s
+  select
+  local.tee $2
+  i32.const 10
+  i32.const 0
+  call $~lib/rt/__newArray
+  local.tee $1
+  i32.store
+  local.get $1
+  i32.load offset=4
+  local.set $4
+  local.get $0
+  i32.load offset=4
+  local.get $3
+  i32.const 2
+  i32.shl
+  i32.add
+  local.set $3
+  i32.const 0
+  local.set $0
+  local.get $2
+  i32.const 2
+  i32.shl
+  local.set $2
+  loop $while-continue|0
+   local.get $0
+   local.get $2
+   i32.lt_u
+   if
+    local.get $0
+    local.get $4
+    i32.add
+    local.get $0
+    local.get $3
+    i32.add
+    i32.load
+    local.tee $5
+    i32.store
+    local.get $1
+    local.get $5
+    i32.const 1
+    call $~lib/rt/itcms/__link
+    local.get $0
+    i32.const 4
+    i32.add
+    local.set $0
+    br $while-continue|0
+   end
+  end
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+  local.get $1
+ )
+ (func $export:assembly/index/solve (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.sub
+  global.set $~lib/memory/__stack_pointer
+  call $~stack_check
+  global.get $~lib/memory/__stack_pointer
+  local.get $0
+  i32.store
+  local.get $0
+  local.get $1
+  local.get $2
+  local.get $3
+  call $assembly/index/solve
+  global.get $~lib/memory/__stack_pointer
+  i32.const 4
+  i32.add
+  global.set $~lib/memory/__stack_pointer
+ )
+ ;; custom section "as-bind_bindings", size 354, contents: "{\"typeIds\":{\"~lib/array/Array<~lib/typedarray/Int64Array>\":{\"id\":5,\"byteSize\":16},\"~lib/typedarray/Int64Array\":{\"id\":4,\"byteSize\":12},\"~lib/array/Array<i64>\":{\"id\":3,\"byteSize\":16}},\"importedFunctions\":{},\"exportedFunctions\":{\"solve\":{\"returnType\":\"~lib/array/Array<~lib/typedarray/Int64Array>\",\"parameters\":[\"~lib/array/Array<i64>\",\"i32\",\"i32\",\"i32\"]}}}"
+)
diff --git a/src/SomaSolution.ts b/src/SomaSolution.ts
index a6f02dd..6176e79 100644
--- a/src/SomaSolution.ts
+++ b/src/SomaSolution.ts
@@ -1,13 +1,16 @@
-import type VoxelSpace from "./VoxelSpace";
+import type VoxelSpaceBoolean from "./VoxelSpaceBoolean";
+import type VoxelSpaceBigInt from "./VoxelSpaceBigInt";
 
 export default class SomaSolution {
-    private solutionSpaces: VoxelSpace[];
-    private dim: number;
-    constructor(dim: number) {
-        if (dim < 0 || dim % 1 !== 0) {
-            throw new Error("Dimension must be a whole positive integer!");
-        }
-        this.dim = dim;
+    private solutionSpaces: (VoxelSpaceBoolean | VoxelSpaceBigInt)[];
+    private dimX: number;
+    private dimY: number;
+    private dimZ: number;
+
+    constructor(dimX: number, dimY: number, dimZ: number) {
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
         this.solutionSpaces = [];
     }
 
@@ -40,7 +43,7 @@ export default class SomaSolution {
         const result: SomaSolution[] = [];
         const allRots = this.solutionSpaces.map(space => space.getAllRotations());
         for (let i = 0; i < allRots[0].length; i++) {
-            const solnRot = new SomaSolution(this.dim);
+            const solnRot = new SomaSolution(this.dimX, this.dimY, this.dimZ);
             allRots.forEach(rotGroup => solnRot.addSpace(rotGroup[i]));
             result.push(solnRot);
         }
@@ -56,16 +59,16 @@ export default class SomaSolution {
         return true;
     }
 
-    addSpace(space: VoxelSpace) {
+    addSpace(space: VoxelSpaceBoolean | VoxelSpaceBigInt) {
         this.solutionSpaces.push(space);
     }
 
     print() {
         let accum = "";
         console.log("---");
-        for (let x = 0; x < this.dim; x++) {
-            for (let y = 0; y < this.dim; y++) {
-                for (let z = 0; z < this.dim; z++) {
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
                     for (const space of this.solutionSpaces) {
                         if (space.at(x, y, z)) {
                             accum += space.getId();
@@ -75,7 +78,7 @@ export default class SomaSolution {
                 console.log(accum);
                 accum = "";
             }
-            if (x !== this.dim - 1) {
+            if (x !== this.dimX - 1) {
                 console.log("-");
             }
         }
@@ -92,19 +95,19 @@ export default class SomaSolution {
     }
 
     clone() {
-        const clone = new SomaSolution(this.dim);
+        const clone = new SomaSolution(this.dimX, this.dimY, this.dimZ);
         clone.solutionSpaces = this.solutionSpaces.slice();
         return clone;
     }
 
     getDims() {
-        return [this.dim, this.dim, this.dim];
+        return [this.dimX, this.dimY, this.dimZ];
     }
 
     forEachCell(cb: (val: number, x: number, y: number, z: number) => any) {
-        loopStart: for (let x = 0; x < this.dim; x++) {
-            for (let y = 0; y < this.dim; y++) {
-                for (let z = 0; z < this.dim; z++) {
+        loopStart: for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
                     cb(this.at(x, y, z), x, y, z);
                 }
             }
diff --git a/src/SomaSolver.ts b/src/SomaSolver.ts
deleted file mode 100644
index 3aa0fc8..0000000
--- a/src/SomaSolver.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import VoxelSpace from "./VoxelSpace";
-import SomaSolution from "./SomaSolution";
-
-export default class SomaSolver {
-    private solutionCube: VoxelSpace;
-    private dim: number;
-    private solutions: SomaSolution[] = [];
-    private iterations: number = 0;
-    constructor(dimension: number) {
-        if (dimension % 1 !== 0 || dimension < 0) {
-            throw new Error("The argument 'dimension' must be a positive whole number");
-        }
-        this.dim = dimension;
-        this.solutionCube = new VoxelSpace(0, [dimension, dimension, dimension], Array(dimension**3).fill(0));
-    }
-
-    async solve(polycubes: VoxelSpace[]) {
-        if (polycubes.length === 0) {
-            throw new Error("You must pass at least one polycube to solve the puzzle.");
-        }
-        let cumulativeSize = polycubes.reduce((prev, curr) => prev + curr.size(), 0);
-        if (cumulativeSize !== this.dim**3) {
-            throw new Error(`The polycubes passed do not add up to exactly enough units to form a cube of dimension ${this.dim}! Got: ${cumulativeSize}, need: ${this.dim**3}`);
-        }
-        this.solutions = [];
-        const combosWithRots = polycubes.slice(1).map(polycube => polycube.getUniqueRotations().map((rot: VoxelSpace) => rot.getAllPositionsInCube(this.dim)).flat());
-        const combos = [polycubes[0].getAllPositionsInCube(this.dim), ...combosWithRots];
-        this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dim));
-        this.solutions = SomaSolution.filterUnique(this.solutions);
-    }
-
-    getSolutions() {
-        return this.solutions.slice();
-    }
-
-    private backtrackSolve(workingSolution: VoxelSpace, polycubes: VoxelSpace[][], currentSoln: SomaSolution, depth = 0) {
-        const nextCubeGroup = polycubes[0];
-        for (let i = 0; i < nextCubeGroup.length; i++) {
-            const fusionAttempt = workingSolution.plus(nextCubeGroup[i]);
-            if (fusionAttempt) {
-                const nextSoln = currentSoln.clone();
-                nextSoln.addSpace(nextCubeGroup[i]);
-                if (polycubes.length === 1) {
-                    this.solutions.push(nextSoln);
-                    currentSoln = new SomaSolution(this.dim);
-                    return;
-                } else {
-                    this.backtrackSolve(fusionAttempt, polycubes.slice(1), nextSoln, depth + 1);
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/VoxelSpace.ts b/src/VoxelSpaceBigInt.ts
similarity index 65%
rename from src/VoxelSpace.ts
rename to src/VoxelSpaceBigInt.ts
index 9519d3d..527994e 100644
--- a/src/VoxelSpace.ts
+++ b/src/VoxelSpaceBigInt.ts
@@ -1,3 +1,5 @@
+import type VoxelSpaceBoolean from "./VoxelSpaceBoolean";
+
 export type DimensionDef = [number, number, number];
 
 const enum NeighbourDirection {
@@ -9,30 +11,28 @@ const enum NeighbourDirection {
     NEGZ,
 }
 
-export default class VoxelSpace {
+export default class VoxelSpaceBigInt {
     private dims: DimensionDef;
     private length: number;
     private space: bigint;
     private id: number;
-    constructor(id: number, dims: DimensionDef, space?: boolean[] | bigint, cullEmpty?: boolean) {
-        if (!space) {
-            space = 0n;
-        } else if (Array.isArray(space)) {
-            if (space.length !== dims[0] * dims[1] * dims[2]) {
-                throw new Error("Vals don't fit in given dimensions.");
-            }
-            space = VoxelSpace.boolArrayToBigInt(space)
+    private color: string;
+
+    constructor(options: {id: number, dims: DimensionDef, space?: bigint, cullEmpty: boolean, color?: string}) {
+        if (!options.space) {
+            options.space = 0n;
         }
-        this.id = id;
-        this.length = dims[0] * dims[1] * dims[2];
-        this.dims = dims;
-        this.space = space;
-        if (cullEmpty) {
+        this.id = options.id;
+        this.length = options.dims[0] * options.dims[1] * options.dims[2];
+        this.dims = options.dims;
+        this.space = BigInt(options.space);
+        this.color = options.color ?? "red";
+        if (options.cullEmpty !== false) {
             this.cullEmptySpace();
         }
     }
 
-    private static boolArrayToBigInt(boolArray: boolean[]): bigint {
+    static boolArrayToBigInt(boolArray: boolean[]) {
         let result = 0n;
         for (let i = 0; i < boolArray.length; i++) {
             if (boolArray[i]) {
@@ -42,18 +42,26 @@ export default class VoxelSpace {
         return result;
     }
 
+    setColor(color: string) {
+        this.color = color;
+    }
+
+    getColor() {
+        return this.color;
+    }
+
     binaryRep() {
         return this.space.toString(2);
     }
 
     getExtrema() {
         const extrema = {
-            xMax: -Infinity,
-            xMin: Infinity,
-            yMax: -Infinity,
-            yMin: Infinity,
-            zMax: -Infinity,
-            zMin: Infinity,
+            xMax: 0,
+            xMin: this.dims[0],
+            yMax: 0,
+            yMin: this.dims[1],
+            zMax: 0,
+            zMin: this.dims[2],
         };
         this.forEachCell((val, x, y, z) => {
             if (val) {
@@ -68,7 +76,7 @@ export default class VoxelSpace {
         return extrema;
     }
 
-    private cullEmptySpace() {
+    cullEmptySpace() {
         const extrema = this.getExtrema();
         let index = 0n;
         let newSpace = 0n;
@@ -123,25 +131,25 @@ export default class VoxelSpace {
     }
 
     getUniqueRotations() {
-        const rotations: VoxelSpace[] = [];
+        const rotations: VoxelSpaceBigInt[] = [];
         const refSpace = this.clone();
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBigInt.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBigInt.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBigInt.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBigInt.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('z');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBigInt.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('z');
         refSpace.rot90('z');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBigInt.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         return rotations;
     }
 
     getAllRotations() {
-        const rotations: VoxelSpace[] = [];
+        const rotations: VoxelSpaceBigInt[] = [];
         const refSpace = this.clone();
         rotations.push(...refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
@@ -158,7 +166,7 @@ export default class VoxelSpace {
         return rotations;
     }
 
-    protected static pushNewUniqueSpaces(existingSpaces: VoxelSpace[], newSpaces: VoxelSpace[]) {
+    protected static pushNewUniqueSpaces(existingSpaces: VoxelSpaceBigInt[], newSpaces: VoxelSpaceBigInt[]) {
         for (const newSpace of newSpaces) {
             let matchFound = false;
             for (const existingSpace of existingSpaces) {
@@ -173,41 +181,44 @@ export default class VoxelSpace {
         }
     }
 
-    getAllPositionsInCube(cubeDim: number): VoxelSpace[] {
-        if ((cubeDim > 0) && (cubeDim % 1 === 0)) {
-            const cubePositions: VoxelSpace[] = [];
-            for (let x = 0; x < cubeDim - this.dims[0] + 1; x++) {
-                for (let y = 0; y < cubeDim - this.dims[1] + 1; y++) {
-                    for (let z = 0; z < cubeDim - this.dims[2] + 1; z++) {
-                        const cubePos = new VoxelSpace(this.id, [cubeDim, cubeDim, cubeDim]);
-                        this.forEachCell((val, rotX, rotY, rotZ) => {
-                            cubePos.set(x + rotX, y + rotY, z + rotZ, val);
-                        });
-                        cubePositions.push(cubePos);
-                    }
+    getAllPositionsInPrism(cubeDimX: number, cubeDimY: number, cubeDimZ: number): VoxelSpaceBigInt[] {
+        const cubePositions: VoxelSpaceBigInt[] = [];
+        if (this.dims[0] > cubeDimX || this.dims[1] > cubeDimY || this.dims[2] > cubeDimZ) {
+            return cubePositions;
+        }
+        for (let xOffset = 0; xOffset < (cubeDimX - this.dims[0] + 1); xOffset++) {
+            for (let yOffset = 0; yOffset < (cubeDimY - this.dims[1] + 1); yOffset++) {
+                for (let zOffset = 0; zOffset < (cubeDimZ - this.dims[2] + 1); zOffset++) {
+                    const cubePos = new VoxelSpaceBigInt({id: this.id, dims: [cubeDimX, cubeDimY, cubeDimZ], color: this.color, cullEmpty: false});
+                    this.forEachCell((val, x, y, z) => {
+                        cubePos.set(xOffset + x, yOffset + y, zOffset + z, val);
+                    });
+                    cubePositions.push(cubePos);
                 }
             }
-            return cubePositions;
-        } else {
-            throw new Error("cubeDim must be a positive integer.");
         }
+        return cubePositions;
     }
 
-    matches(space: VoxelSpace) {
+    matches(space: VoxelSpaceBigInt | VoxelSpaceBoolean) {
         const otherDims = space.getDims();
         for (let i = 0; i < this.dims.length; i++) {
             if (otherDims[i] !== this.dims[i]) {
                 return false;
             }
         }
-        return this.space === space.getRaw();
+        if (typeof space.getRaw() === "bigint") {
+            return this.space === space.getRaw();
+        } else {
+            return this.binaryRep() === space.binaryRep();
+        }
     }
 
     clone() {
-        return new VoxelSpace(this.id, this.getDims(), this.getRaw());
+        return new VoxelSpaceBigInt({id: this.id, dims: this.getDims(), space: this.getRaw(), color: this.getColor(), cullEmpty: false});
     }
 
-    private getAxisSpins(axis: 'x' | 'y' | 'z'): VoxelSpace[] {
+    private getAxisSpins(axis: 'x' | 'y' | 'z'): VoxelSpaceBigInt[] {
         const rotations = [this.clone()];
         for (let i = 0; i < 3; i++) {
             rotations.push(rotations[i].rotated90(axis));
@@ -250,30 +261,33 @@ export default class VoxelSpace {
     }
 
     toggle(x: number, y: number, z: number) {
-        const mask = BigInt(1 << this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
+        const mask = 1n << BigInt(this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
         this.space ^= mask;
     }
 
     set(x: number, y: number, z: number, val: boolean) {
-        const mask = BigInt(1 << this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
+        const mask = 1n << BigInt(this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
         if (val) {
             this.space |= mask;
-        } else {
+        }
+        else {
             this.space &= ~mask;
         }
     }
 
     rotated90(dim: 'x' | 'y' | 'z') {
         let newSpace = 0n;
-        let newDims: DimensionDef;
-        let rotIndex: (i: number, j: number, k: number) => number;
+        let newDims;
+        let rotIndex;
         if (dim === 'x') {
             newDims = [this.dims[0], this.dims[2], this.dims[1]];
             rotIndex = this.newIndexRotX.bind(this);
-        } else if (dim === 'y') {
+        }
+        else if (dim === 'y') {
             newDims = [this.dims[2], this.dims[1], this.dims[0]];
             rotIndex = this.newIndexRotY.bind(this);
-        } else {
+        }
+        else {
             newDims = [this.dims[1], this.dims[0], this.dims[2]];
             rotIndex = this.newIndexRotZ.bind(this);
         }
@@ -281,8 +295,8 @@ export default class VoxelSpace {
             if (val) {
                 newSpace |= BigInt(1 << rotIndex(i, j, k));
             }
-        })
-        return new VoxelSpace(this.id, newDims, newSpace);
+        });
+        return new VoxelSpaceBigInt({ id: this.id, dims: newDims, space: newSpace, color: this.color, cullEmpty: false });
     }
 
     rot90(dim: 'x' | 'y' | 'z') {
@@ -291,10 +305,10 @@ export default class VoxelSpace {
         this.dims = rot.getDims();
     }
 
-    plus(space: VoxelSpace): VoxelSpace | null {
+    plus(space: VoxelSpaceBigInt): VoxelSpaceBigInt | null {
         const otherSpace = space.getRaw();
         if ((this.space | otherSpace) === (this.space ^ otherSpace)) {
-            return new VoxelSpace(this.id, this.dims, otherSpace | this.space);
+            return new VoxelSpaceBigInt({ id: this.id, dims: this.getDims(), space: otherSpace | this.space, color: this.color, cullEmpty: false });
         }
         return null;
     }
@@ -331,4 +345,13 @@ export default class VoxelSpace {
         }
         return result;
     }
+
+    getAllPermutationsInPrism(prismDimX: number, prismDimY: number, prismDimZ: number): VoxelSpaceBigInt[] {
+        const rotations = this.getUniqueRotations();
+        let result = new Array<VoxelSpaceBigInt>();
+        for (let i = 0; i < rotations.length; i++) {
+            result = result.concat(rotations[i].getAllPositionsInPrism(prismDimX, prismDimY, prismDimZ));
+        }
+        return result;
+    }
 }
\ No newline at end of file
diff --git a/src/VoxelSpaceBoolean.ts b/src/VoxelSpaceBoolean.ts
new file mode 100644
index 0000000..fa17e1a
--- /dev/null
+++ b/src/VoxelSpaceBoolean.ts
@@ -0,0 +1,366 @@
+import type VoxelSpaceBigInt from "./VoxelSpaceBigInt";
+
+export type DimensionDef = [number, number, number];
+
+const enum NeighbourDirection {
+    POSX,
+    POSY,
+    POSZ,
+    NEGX,
+    NEGY,
+    NEGZ,
+}
+
+export default class VoxelSpaceBoolean {
+    private dims: DimensionDef;
+    private length: number;
+    private space: boolean[];
+    private id: number;
+    private color: string;
+
+    constructor(options: {id: number, dims: DimensionDef, space?: boolean[] | bigint, cullEmpty: boolean, color?: string}) {
+        this.length = options.dims[0] * options.dims[1] * options.dims[2];
+        if (!options.space) {
+            options.space = new Array<boolean>(options.dims[0] * options.dims[1] * options.dims[2]);
+            options.space.fill(false);
+        } else if (!Array.isArray(options.space)) {
+            const newSpace = [];
+            for (let i = 0; i < this.length; i++) {
+                const mask = 1n << BigInt(i);
+                newSpace.push((options.space & mask) !== 0n);
+            }
+            options.space = newSpace;
+        }
+        this.id = options.id;
+        this.dims = options.dims;
+        this.space = options.space;
+        this.color = options.color ?? "red";
+        if (options.cullEmpty !== false) {
+            this.cullEmptySpace();
+        }
+    }
+
+    setColor(color: string) {
+        this.color = color;
+    }
+
+    getColor() {
+        return this.color;
+    }
+
+    binaryRep() {
+        return this.space.reduce((prev, curr) => prev + (curr ? "1" : "0"), "");
+    }
+
+    getExtrema() {
+        const extrema = {
+            xMax: 0,
+            xMin: this.dims[0],
+            yMax: 0,
+            yMin: this.dims[1],
+            zMax: 0,
+            zMin: this.dims[2],
+        };
+        this.forEachCell((val, x, y, z) => {
+            if (val) {
+                extrema.xMax = Math.max(extrema.xMax, x);
+                extrema.xMin = Math.min(extrema.xMin, x);
+                extrema.yMax = Math.max(extrema.yMax, y);
+                extrema.yMin = Math.min(extrema.yMin, y);
+                extrema.zMax = Math.max(extrema.zMax, z);
+                extrema.zMin = Math.min(extrema.zMin, z);
+            }
+        });
+        return extrema;
+    }
+
+    cullEmptySpace() {
+        const extrema = this.getExtrema();
+        const newX = extrema.xMax - extrema.xMin + 1;
+        const newY = extrema.yMax - extrema.yMin + 1;
+        const newZ = extrema.zMax - extrema.zMin + 1;
+        const newSpace = new Array<boolean>(newX * newY * newZ);
+        newSpace.fill(false);
+        let index = 0;
+        for (let x = extrema.xMin; x <= extrema.xMax; x++) {
+            for (let y = extrema.yMin; y <= extrema.yMax; y++) {
+                for (let z = extrema.zMin; z <= extrema.zMax; z++) {
+                    if (this.at(x, y, z)) {
+                        newSpace[index] = true;
+                    }
+                    index++;
+                }
+            }
+        }
+        this.dims[0] = newX;
+        this.dims[1] = newY;
+        this.dims[2] = newZ;
+        this.space = newSpace;
+    }
+
+    forEachCell(cb: (val: boolean, x: number, y: number, z: number) => any) {
+        loopStart: for (let x = 0; x < this.dims[0]; x++) {
+            for (let y = 0; y < this.dims[1]; y++) {
+                for (let z = 0; z < this.dims[2]; z++) {
+                    if (cb(this.at(x, y, z), x, y, z) === 0) {
+                        break loopStart;
+                    }
+                }
+            }
+        }
+    }
+
+    getId() {
+        return this.id;
+    }
+
+    print() {
+        let accum = "";
+        console.log("---");
+        for (let i = 0; i < this.dims[0]; i++) {
+            for (let j = 0; j < this.dims[1]; j++) {
+                for (let k = 0; k < this.dims[2]; k++) {
+                    accum += this.at(i, j, k) ? '#' : 'O';
+                }
+                console.log(accum);
+                accum = "";
+            }
+            if (i !== this.dims[0] - 1) {
+                console.log("-");
+            }
+        }
+        console.log("---");
+    }
+
+    getUniqueRotations() {
+        const rotations: VoxelSpaceBoolean[] = [];
+        const refSpace = this.clone();
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('z');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('z');
+        refSpace.rot90('z');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        return rotations;
+    }
+
+    getAllRotations() {
+        const rotations: VoxelSpaceBoolean[] = [];
+        const refSpace = this.clone();
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('z');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('z');
+        refSpace.rot90('z');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        return rotations;
+    }
+
+    protected static pushNewUniqueSpaces(existingSpaces: VoxelSpaceBoolean[], newSpaces: VoxelSpaceBoolean[]) {
+        for (const newSpace of newSpaces) {
+            let matchFound = false;
+            for (const existingSpace of existingSpaces) {
+                if (newSpace.matches(existingSpace)) {
+                    matchFound = true;
+                    break;
+                }
+            }
+            if (!matchFound) {
+                existingSpaces.push(newSpace);
+            }
+        }
+    }
+
+    getAllPositionsInPrism(cubeDimX: number, cubeDimY: number, cubeDimZ: number): VoxelSpaceBoolean[] {
+        const cubePositions: VoxelSpaceBoolean[] = [];
+        if (this.dims[0] > cubeDimX || this.dims[1] > cubeDimY || this.dims[2] > cubeDimZ) {
+            return cubePositions;
+        }
+        for (let xOffset = 0; xOffset < (cubeDimX - this.dims[0] + 1); xOffset++) {
+            for (let yOffset = 0; yOffset < (cubeDimY - this.dims[1] + 1); yOffset++) {
+                for (let zOffset = 0; zOffset < (cubeDimZ - this.dims[2] + 1); zOffset++) {
+                    const cubePos = new VoxelSpaceBoolean({id: this.id, dims: [cubeDimX, cubeDimY, cubeDimZ], color: this.color, cullEmpty: false});
+                    this.forEachCell((val, x, y, z) => {
+                        cubePos.set(xOffset + x, yOffset + y, zOffset + z, val);
+                    });
+                    cubePositions.push(cubePos);
+                }
+            }
+        }
+        return cubePositions;
+    }
+
+    matches(space: VoxelSpaceBoolean | VoxelSpaceBigInt) {
+        const otherDims = space.getDims();
+        for (let i = 0; i < this.dims.length; i++) {
+            if (otherDims[i] !== this.dims[i]) {
+                return false;
+            }
+        }
+        const otherRaw = space.getRaw();
+        if (typeof otherRaw === "bigint") {
+            return space.binaryRep() === this.binaryRep();
+        }
+        return this.space.reduce((prev, unit, i) => (unit === otherRaw[i]) && prev, true);
+    }
+
+    clone() {
+        return new VoxelSpaceBoolean({id: this.id, dims: this.getDims(), space: this.getRaw(), color: this.getColor(), cullEmpty: false});
+    }
+
+    private getAxisSpins(axis: 'x' | 'y' | 'z'): VoxelSpaceBoolean[] {
+        const rotations = [this.clone()];
+        for (let i = 0; i < 3; i++) {
+            rotations.push(rotations[i].rotated90(axis));
+        }
+        return rotations;
+    }
+
+    getDims(): DimensionDef {
+        return this.dims.slice() as DimensionDef;
+    }
+
+    getRaw() {
+        return this.space.slice();
+    }
+
+    // [1, 0,  0]   [x]   [ x]
+    // [0, 0, -1] * [y] = [-z]
+    // [0, 1,  0]   [z]   [ y]
+    private newIndexRotX(x: number, y: number, z: number) {
+        return this.dims[2] * this.dims[1] * x + this.dims[1] * (this.dims[2] - 1 - z) + y;
+    }
+
+    // [ 0, 0, 1]   [x]   [ z]
+    // [ 0, 1, 0] * [y] = [ y]
+    // [-1, 0, 0]   [z]   [-x]
+    private newIndexRotY(x: number, y: number, z: number) {
+        return this.dims[1] * this.dims[0] * z + this.dims[0] * y + (this.dims[0] - 1 - x);
+    }
+
+    // [0, -1, 0]     [x]   [-y]
+    // [1,  0, 0]  *  [y] = [ x]
+    // [0,  0, 1]     [z]   [ z]
+    private newIndexRotZ(x: number, y: number, z: number) {
+        return this.dims[0] * this.dims[2] * (this.dims[1] - 1 - y) + this.dims[2] * x + z;
+    }
+
+    at(x: number, y: number, z: number) {
+        return this.space[this.index(x, y, z)];
+    }
+
+    private index(x: number, y: number, z: number) {
+        return this.dims[1] * this.dims[2] * x + this.dims[2] * y + z;
+    }
+
+    toggle(x: number, y: number, z: number) {
+        const index = this.index(x, y, z);
+        this.space[index] = !this.space[index];
+    }
+
+    set(x: number, y: number, z: number, val: boolean) {
+        this.space[this.index(x, y, z)] = val;
+    }
+
+    rotated90(dim: 'x' | 'y' | 'z') {
+        const newSpace = new Array<boolean>(this.dims[0] * this.dims[1] * this.dims[2]);
+        newSpace.fill(false);
+        let newDims: DimensionDef;
+        let rotIndex: (i: number, j: number, k: number) => number;
+        if (dim === 'x') {
+            newDims = [this.dims[0], this.dims[2], this.dims[1]];
+            rotIndex = this.newIndexRotX.bind(this);
+        } else if (dim === 'y') {
+            newDims = [this.dims[2], this.dims[1], this.dims[0]];
+            rotIndex = this.newIndexRotY.bind(this);
+        } else {
+            newDims = [this.dims[1], this.dims[0], this.dims[2]];
+            rotIndex = this.newIndexRotZ.bind(this);
+        }
+        this.forEachCell((val, i, j, k) => {
+            if (val) {
+                newSpace[rotIndex(i, j, k)] = true;
+            }
+        })
+        return new VoxelSpaceBoolean({id: this.id, dims: newDims, space: newSpace, color: this.color, cullEmpty: false});
+    }
+
+    rot90(dim: 'x' | 'y' | 'z') {
+        const rot = this.rotated90(dim);
+        this.space = rot.getRaw();
+        this.dims = rot.getDims();
+    }
+
+    plus(space: VoxelSpaceBoolean): VoxelSpaceBoolean | null {
+        const newSpace = new Array<boolean>(this.dims[0] * this.dims[1] * this.dims[2]);
+        newSpace.fill(false);
+        let clash = false;
+        space.forEachCell((val, x, y, z) => {
+            if (this.at(x, y, z) !== val) {
+                newSpace[this.index(x, y, z)] = true;
+            } else {
+                if (val) {
+                    clash = true;
+                }
+            }
+        });
+        if (!clash) {
+            return new VoxelSpaceBoolean({id: this.id, dims: this.getDims(), space: newSpace, color: this.color, cullEmpty: false});
+        }
+        return null;
+    }
+
+    size() {
+        let size = 0;
+        this.forEachCell((val) => {
+            if (val) {
+                size++;
+            }
+        });
+        return size;
+    }
+
+    getDirectNeighbourProfile(x: number, y: number, z: number): number {
+        let result = 0;
+        if (x < this.dims[0] - 1 && this.at(x + 1, y, z)) {
+            result += 1;
+        }
+        if (y < this.dims[1] - 1 && this.at(x, y + 1, z)) {
+            result += 2;
+        }
+        if (z < this.dims[2] - 1 && this.at(x, y, z + 1)) {
+            result += 4;
+        }
+        if (x > 0 && this.at(x - 1, y, z)) {
+            result += 8;
+        }
+        if (y > 0 && this.at(x, y - 1, z)) {
+            result += 16;
+        }
+        if (z > 0 && this.at(x, y, z - 1)) {
+            result += 32;
+        }
+        return result;
+    }
+
+    getAllPermutationsInPrism(prismDimX: number, prismDimY: number, prismDimZ: number): VoxelSpaceBoolean[] {
+        const rotations = this.getUniqueRotations();
+        let result = new Array<VoxelSpaceBoolean>();
+        for (let i = 0; i < rotations.length; i++) {
+            result = result.concat(rotations[i].getAllPositionsInPrism(prismDimX, prismDimY, prismDimZ));
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/src/desktop/build.js b/src/desktop/build.js
new file mode 100644
index 0000000..e69de29
diff --git a/src/desktop/main.js b/src/desktop/main.js
new file mode 100644
index 0000000..78576d7
--- /dev/null
+++ b/src/desktop/main.js
@@ -0,0 +1,30 @@
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+
+function createWindow() {
+    const win = new BrowserWindow({
+        width: 800,
+        height: 600,
+        webPreferences: {
+            preload: path.join(__dirname, 'preload.js'),
+        }
+    });
+
+    win.loadFile(path.join(__dirname, '../../public/index.html'));
+}
+
+app.whenReady().then(() => {
+    createWindow();
+
+    app.on('activate', function() {
+        if (BrowserWindow.getAllWindows().length === 0) {
+            createWindow();
+        }
+    })
+});
+
+app.on('window-all-close', function() {
+    if (process.platform !== 'darwin') {
+        app.quit();
+    }
+});
\ No newline at end of file
diff --git a/src/desktop/preload.js b/src/desktop/preload.js
new file mode 100644
index 0000000..190801e
--- /dev/null
+++ b/src/desktop/preload.js
@@ -0,0 +1,12 @@
+window.addEventListener('DOMContentLoaded', () => {
+    const replaceText = (selector, text) => {
+        const element = document.getElementById(selector);
+        if (element) {
+            element.innerText = text;
+        }
+
+    }
+    for (const dependency of ['chrome', 'node', 'electron']) {
+        replaceText(`${dependency}-version`, process.versions[dependency]);
+    }
+});
\ No newline at end of file
diff --git a/public/solver/SomaSolution.js b/src/solver/js/SomaSolution.js
similarity index 69%
rename from public/solver/SomaSolution.js
rename to src/solver/js/SomaSolution.js
index ede6460..aa206fb 100644
--- a/public/solver/SomaSolution.js
+++ b/src/solver/js/SomaSolution.js
@@ -1,9 +1,8 @@
 export default class SomaSolution {
-    constructor(dim) {
-        if (dim < 0 || dim % 1 !== 0) {
-            throw new Error("Dimension must be a whole positive integer!");
-        }
-        this.dim = dim;
+    constructor(dimX, dimY, dimZ) {
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
         this.solutionSpaces = [];
     }
     static filterUnique(solutions) {
@@ -13,7 +12,7 @@ export default class SomaSolution {
         const uniqueSolns = [solutions[0]];
         for (const solution of solutions) {
             let foundMatch = false;
-            for (const rotation of solution.getUniqueRotations()) {
+            for (const rotation of solution.getRotations()) {
                 let end = uniqueSolns.length;
                 for (let i = 0; i < end; i++) {
                     if (rotation.matches(uniqueSolns[i])) {
@@ -27,14 +26,14 @@ export default class SomaSolution {
         }
         return uniqueSolns;
     }
-    getUniqueRotations() {
+    getRotations() {
         if (this.solutionSpaces.length === 0) {
             return [];
         }
         const result = [];
         const allRots = this.solutionSpaces.map(space => space.getAllRotations());
         for (let i = 0; i < allRots[0].length; i++) {
-            const solnRot = new SomaSolution(this.dim);
+            const solnRot = new SomaSolution(this.dimX, this.dimY, this.dimZ);
             allRots.forEach(rotGroup => solnRot.addSpace(rotGroup[i]));
             result.push(solnRot);
         }
@@ -54,9 +53,9 @@ export default class SomaSolution {
     print() {
         let accum = "";
         console.log("---");
-        for (let x = 0; x < this.dim; x++) {
-            for (let y = 0; y < this.dim; y++) {
-                for (let z = 0; z < this.dim; z++) {
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
                     for (const space of this.solutionSpaces) {
                         if (space.at(x, y, z)) {
                             accum += space.getId();
@@ -66,7 +65,7 @@ export default class SomaSolution {
                 console.log(accum);
                 accum = "";
             }
-            if (x !== this.dim - 1) {
+            if (x !== this.dimX - 1) {
                 console.log("-");
             }
         }
@@ -81,8 +80,23 @@ export default class SomaSolution {
         return 0;
     }
     clone() {
-        const clone = new SomaSolution(this.dim);
+        const clone = new SomaSolution(this.dimX, this.dimY, this.dimZ);
         clone.solutionSpaces = this.solutionSpaces.slice();
         return clone;
     }
+    getDims() {
+        return [this.dimX, this.dimY, this.dimZ];
+    }
+    forEachCell(cb) {
+        loopStart: for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
+                    cb(this.at(x, y, z), x, y, z);
+                }
+            }
+        }
+    }
+    getPieces() {
+        return this.solutionSpaces.slice();
+    }
 }
diff --git a/src/solver/js/SomaSolution.ts b/src/solver/js/SomaSolution.ts
new file mode 100644
index 0000000..d5dc923
--- /dev/null
+++ b/src/solver/js/SomaSolution.ts
@@ -0,0 +1,119 @@
+import type VoxelSpaceBoolean from "./VoxelSpaceBoolean";
+
+export default class SomaSolution {
+    private solutionSpaces: VoxelSpaceBoolean[];
+    private dimX: number;
+    private dimY: number;
+    private dimZ: number;
+
+    constructor(dimX: number, dimY: number, dimZ: number) {
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
+        this.solutionSpaces = [];
+    }
+
+    static filterUnique(solutions: SomaSolution[]): SomaSolution[] {
+        if (solutions.length === 0) {
+            return [];
+        }
+        const uniqueSolns = [solutions[0]];
+        for (const solution of solutions) {
+            let foundMatch = false;
+            for (const rotation of solution.getRotations()) {
+                let end = uniqueSolns.length;
+                for (let i = 0; i < end; i++) {
+                    if (rotation.matches(uniqueSolns[i])) {
+                        foundMatch = true;
+                    }
+                }
+            }
+            if (!foundMatch) {
+                uniqueSolns.push(solution);
+            }
+        }
+        return uniqueSolns;
+    }
+
+    getRotations(): SomaSolution[] {
+        if (this.solutionSpaces.length === 0) {
+            return [];
+        }
+        const result: SomaSolution[] = [];
+        const allRots = this.solutionSpaces.map(space => space.getAllRotations());
+        for (let i = 0; i < allRots[0].length; i++) {
+            const solnRot = new SomaSolution(this.dimX, this.dimY, this.dimZ);
+            allRots.forEach(rotGroup => solnRot.addSpace(rotGroup[i]));
+            result.push(solnRot);
+        }
+        return result;
+    }
+
+    matches(solution: SomaSolution) {
+        for (let i = 0; i < this.solutionSpaces.length; i++) {
+            if (!this.solutionSpaces[i].matches(solution.solutionSpaces[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    addSpace(space: VoxelSpaceBoolean) {
+        this.solutionSpaces.push(space);
+    }
+
+    print() {
+        let accum = "";
+        console.log("---");
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
+                    for (const space of this.solutionSpaces) {
+                        if (space.at(x, y, z)) {
+                            accum += space.getId();
+                        }
+                    }
+                }
+                console.log(accum);
+                accum = "";
+            }
+            if (x !== this.dimX - 1) {
+                console.log("-");
+            }
+        }
+        console.log("---");
+    }
+
+    at(x: number, y: number, z: number) {
+        for (const space of this.solutionSpaces) {
+            if (space.at(x, y, z)) {
+                return space.getId();
+            }
+        }
+        return 0;
+    }
+
+    clone() {
+        const clone = new SomaSolution(this.dimX, this.dimY, this.dimZ);
+        clone.solutionSpaces = this.solutionSpaces.slice();
+        return clone;
+    }
+
+    getDims() {
+        return [this.dimX, this.dimY, this.dimZ];
+    }
+
+    forEachCell(cb: (val: number, x: number, y: number, z: number) => any) {
+        loopStart: for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
+                    cb(this.at(x, y, z), x, y, z);
+                }
+            }
+        }
+    }
+
+    getPieces() {
+        return this.solutionSpaces.slice();
+    }
+}
\ No newline at end of file
diff --git a/src/solver/js/SomaSolver.js b/src/solver/js/SomaSolver.js
new file mode 100644
index 0000000..985c625
--- /dev/null
+++ b/src/solver/js/SomaSolver.js
@@ -0,0 +1,60 @@
+import VoxelSpaceBoolean from "./VoxelSpaceBoolean";
+import SomaSolution from "./SomaSolution";
+export default class SomaSolver {
+    constructor(dimX, dimY, dimZ) {
+        this.visualiser = { async showSoln(soln) { }, async showSpace(cube) { } };
+        this.solutions = new Array();
+        this.iterations = 0;
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
+        this.solutionCube = new VoxelSpaceBoolean({ id: 0, dims: [dimX, dimY, dimZ], cullEmpty: false });
+    }
+    setDebug(visualiser) {
+        this.visualiser = visualiser;
+    }
+    async solve(polycubes) {
+        if (polycubes.length === 0) {
+            throw new Error("You must pass at least one polycube to solve the puzzle.");
+        }
+        this.solutions.splice(0, this.solutions.length);
+        const combosWithRots = new Array();
+        for (let i = 1; i < polycubes.length; i++) {
+            const rots = polycubes[i].getAllPermutationsInPrism(this.dimX, this.dimY, this.dimZ);
+            combosWithRots.push(rots);
+        }
+        let combos = new Array();
+        combos.push(polycubes[0].getAllPositionsInPrism(this.dimX, this.dimY, this.dimZ));
+        combos = combos.concat(combosWithRots);
+        for (const combo of combos) {
+            for (const rot of combo) {
+                await this.visualiser.showSpace(rot);
+            }
+        }
+        await this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dimX, this.dimY, this.dimZ));
+        this.solutions = SomaSolution.filterUnique(this.solutions);
+    }
+    getSolutions() {
+        return this.solutions.slice();
+    }
+    async backtrackSolve(workingSolution, polycubes, currentSoln, depth = 0) {
+        const nextCubeGroup = polycubes[0];
+        for (let i = 0; i < nextCubeGroup.length; i++) {
+            const fusionAttempt = workingSolution.plus(nextCubeGroup[i]);
+            ++this.iterations;
+            if (fusionAttempt) {
+                const nextSoln = currentSoln.clone();
+                nextSoln.addSpace(nextCubeGroup[i]);
+                await this.visualiser.showSoln(nextSoln);
+                if (polycubes.length === 1) {
+                    this.solutions.push(nextSoln);
+                    currentSoln = new SomaSolution(this.dimX, this.dimY, this.dimZ);
+                    return;
+                }
+                else {
+                    await this.backtrackSolve(fusionAttempt, polycubes.slice(1), nextSoln, depth + 1);
+                }
+            }
+        }
+    }
+}
diff --git a/src/solver/js/SomaSolver.ts b/src/solver/js/SomaSolver.ts
new file mode 100644
index 0000000..aba319d
--- /dev/null
+++ b/src/solver/js/SomaSolver.ts
@@ -0,0 +1,73 @@
+import VoxelSpaceBoolean from "./VoxelSpaceBoolean";
+import SomaSolution from "./SomaSolution";
+
+interface DebugVisualiser {
+    showSoln(soln: SomaSolution): Promise<void>;
+    showSpace(cube: VoxelSpaceBoolean): Promise<void>;
+}
+
+export default class SomaSolver {
+    private solutionCube: VoxelSpaceBoolean;
+    private dimX: number;
+    private dimY: number;
+    private dimZ: number;
+    private visualiser: DebugVisualiser = {async showSoln(soln: SomaSolution) {}, async showSpace(cube: VoxelSpaceBoolean) {}};
+    private solutions: SomaSolution[] = new Array<SomaSolution>();
+    private iterations: number = 0;
+    constructor(dimX: number, dimY: number, dimZ: number) {
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
+        this.solutionCube = new VoxelSpaceBoolean({id: 0, dims: [dimX, dimY, dimZ], cullEmpty: false});
+    }
+
+    setDebug(visualiser: DebugVisualiser) {
+        this.visualiser = visualiser;
+    }
+
+    async solve(polycubes: VoxelSpaceBoolean[]) {
+        if (polycubes.length === 0) {
+            throw new Error("You must pass at least one polycube to solve the puzzle.");
+        }
+        this.solutions.splice(0, this.solutions.length);
+        const combosWithRots: VoxelSpaceBoolean[][] = new Array<Array<VoxelSpaceBoolean>>();
+        for (let i = 1; i < polycubes.length; i++) {
+            const rots = polycubes[i].getAllPermutationsInPrism(this.dimX, this.dimY, this.dimZ);
+            combosWithRots.push(rots);
+        }
+        let combos: VoxelSpaceBoolean[][] = new Array<Array<VoxelSpaceBoolean>>();
+        combos.push(polycubes[0].getAllPositionsInPrism(this.dimX, this.dimY, this.dimZ));
+        combos = combos.concat(combosWithRots);
+        for (const combo of combos) {
+            for (const rot of combo) {
+                await this.visualiser.showSpace(rot);
+            }
+        }
+        await this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dimX, this.dimY, this.dimZ));
+        this.solutions = SomaSolution.filterUnique(this.solutions);
+    }
+
+    getSolutions() {
+        return this.solutions.slice();
+    }
+
+    private async backtrackSolve(workingSolution: VoxelSpaceBoolean, polycubes: VoxelSpaceBoolean[][], currentSoln: SomaSolution, depth = 0) {
+        const nextCubeGroup = polycubes[0];
+        for (let i = 0; i < nextCubeGroup.length; i++) {
+            const fusionAttempt = workingSolution.plus(nextCubeGroup[i]);
+            ++this.iterations;
+            if (fusionAttempt) {
+                const nextSoln = currentSoln.clone();
+                nextSoln.addSpace(nextCubeGroup[i]);
+                await this.visualiser.showSoln(nextSoln);
+                if (polycubes.length === 1) {
+                    this.solutions.push(nextSoln);
+                    currentSoln = new SomaSolution(this.dimX, this.dimY, this.dimZ);
+                    return;
+                } else {
+                    await this.backtrackSolve(fusionAttempt, polycubes.slice(1), nextSoln, depth + 1);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/public/solver/VoxelSpace.js b/src/solver/js/VoxelSpaceBoolean.js
similarity index 52%
rename from public/solver/VoxelSpace.js
rename to src/solver/js/VoxelSpaceBoolean.js
index b480eee..bf6390b 100644
--- a/public/solver/VoxelSpace.js
+++ b/src/solver/js/VoxelSpaceBoolean.js
@@ -1,42 +1,43 @@
-export default class VoxelSpace {
-    constructor(id, dims, space, cullEmpty) {
-        if (!space) {
-            space = 0n;
+export default class VoxelSpaceBoolean {
+    constructor(options) {
+        this.length = options.dims[0] * options.dims[1] * options.dims[2];
+        if (!options.space) {
+            options.space = new Array(options.dims[0] * options.dims[1] * options.dims[2]);
+            options.space.fill(false);
         }
-        else if (Array.isArray(space)) {
-            if (space.length !== dims[0] * dims[1] * dims[2]) {
-                throw new Error("Vals don't fit in given dimensions.");
+        else if (!Array.isArray(options.space)) {
+            const newSpace = [];
+            for (let i = 0; i < this.length; i++) {
+                const mask = 1n << BigInt(i);
+                newSpace.push((options.space & mask) !== 0n);
             }
-            space = VoxelSpace.boolArrayToBigInt(space);
+            options.space = newSpace;
         }
-        this.id = id;
-        this.length = dims[0] * dims[1] * dims[2];
-        this.dims = dims;
-        this.space = space;
-        if (cullEmpty) {
+        this.id = options.id;
+        this.dims = options.dims;
+        this.space = options.space;
+        this.color = options.color ?? "red";
+        if (options.cullEmpty !== false) {
             this.cullEmptySpace();
         }
     }
-    static boolArrayToBigInt(boolArray) {
-        let result = 0n;
-        for (let i = 0; i < boolArray.length; i++) {
-            if (boolArray[i]) {
-                result |= BigInt(1 << i);
-            }
-        }
-        return result;
+    setColor(color) {
+        this.color = color;
+    }
+    getColor() {
+        return this.color;
     }
     binaryRep() {
-        return this.space.toString(2);
+        return this.space.reduce((prev, curr) => prev + (curr ? "1" : "0"), "");
     }
     getExtrema() {
         const extrema = {
-            xMax: -Infinity,
-            xMin: Infinity,
-            yMax: -Infinity,
-            yMin: Infinity,
-            zMax: -Infinity,
-            zMin: Infinity,
+            xMax: 0,
+            xMin: this.dims[0],
+            yMax: 0,
+            yMin: this.dims[1],
+            zMax: 0,
+            zMin: this.dims[2],
         };
         this.forEachCell((val, x, y, z) => {
             if (val) {
@@ -52,21 +53,25 @@ export default class VoxelSpace {
     }
     cullEmptySpace() {
         const extrema = this.getExtrema();
-        let index = 0n;
-        let newSpace = 0n;
+        const newX = extrema.xMax - extrema.xMin + 1;
+        const newY = extrema.yMax - extrema.yMin + 1;
+        const newZ = extrema.zMax - extrema.zMin + 1;
+        const newSpace = new Array(newX * newY * newZ);
+        newSpace.fill(false);
+        let index = 0;
         for (let x = extrema.xMin; x <= extrema.xMax; x++) {
             for (let y = extrema.yMin; y <= extrema.yMax; y++) {
                 for (let z = extrema.zMin; z <= extrema.zMax; z++) {
                     if (this.at(x, y, z)) {
-                        newSpace |= 1n << index;
+                        newSpace[index] = true;
                     }
                     index++;
                 }
             }
         }
-        this.dims[0] = extrema.xMax - extrema.xMin + 1;
-        this.dims[1] = extrema.yMax - extrema.yMin + 1;
-        this.dims[2] = extrema.zMax - extrema.zMin + 1;
+        this.dims[0] = newX;
+        this.dims[1] = newY;
+        this.dims[2] = newZ;
         this.space = newSpace;
     }
     forEachCell(cb) {
@@ -103,18 +108,18 @@ export default class VoxelSpace {
     getUniqueRotations() {
         const rotations = [];
         const refSpace = this.clone();
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('y');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('z');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         refSpace.rot90('z');
         refSpace.rot90('z');
-        VoxelSpace.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
         return rotations;
     }
     getAllRotations() {
@@ -148,25 +153,23 @@ export default class VoxelSpace {
             }
         }
     }
-    getAllPositionsInCube(cubeDim) {
-        if ((cubeDim > 0) && (cubeDim % 1 === 0)) {
-            const cubePositions = [];
-            for (let x = 0; x < cubeDim - this.dims[0] + 1; x++) {
-                for (let y = 0; y < cubeDim - this.dims[1] + 1; y++) {
-                    for (let z = 0; z < cubeDim - this.dims[2] + 1; z++) {
-                        const cubePos = new VoxelSpace(this.id, [cubeDim, cubeDim, cubeDim]);
-                        this.forEachCell((val, rotX, rotY, rotZ) => {
-                            cubePos.set(x + rotX, y + rotY, z + rotZ, val);
-                        });
-                        cubePositions.push(cubePos);
-                    }
-                }
-            }
+    getAllPositionsInPrism(cubeDimX, cubeDimY, cubeDimZ) {
+        const cubePositions = [];
+        if (this.dims[0] > cubeDimX || this.dims[1] > cubeDimY || this.dims[2] > cubeDimZ) {
             return cubePositions;
         }
-        else {
-            throw new Error("cubeDim must be a positive integer.");
+        for (let xOffset = 0; xOffset < (cubeDimX - this.dims[0] + 1); xOffset++) {
+            for (let yOffset = 0; yOffset < (cubeDimY - this.dims[1] + 1); yOffset++) {
+                for (let zOffset = 0; zOffset < (cubeDimZ - this.dims[2] + 1); zOffset++) {
+                    const cubePos = new VoxelSpaceBoolean({ id: this.id, dims: [cubeDimX, cubeDimY, cubeDimZ], color: this.color, cullEmpty: false });
+                    this.forEachCell((val, x, y, z) => {
+                        cubePos.set(xOffset + x, yOffset + y, zOffset + z, val);
+                    });
+                    cubePositions.push(cubePos);
+                }
+            }
         }
+        return cubePositions;
     }
     matches(space) {
         const otherDims = space.getDims();
@@ -175,10 +178,14 @@ export default class VoxelSpace {
                 return false;
             }
         }
-        return this.space === space.getRaw();
+        const otherRaw = space.getRaw();
+        if (typeof otherRaw === "bigint") {
+            return space.binaryRep() === this.binaryRep();
+        }
+        return this.space.reduce((prev, unit, i) => (unit === otherRaw[i]) && prev, true);
     }
     clone() {
-        return new VoxelSpace(this.id, this.getDims(), this.getRaw());
+        return new VoxelSpaceBoolean({ id: this.id, dims: this.getDims(), space: this.getRaw(), color: this.getColor(), cullEmpty: false });
     }
     getAxisSpins(axis) {
         const rotations = [this.clone()];
@@ -191,7 +198,7 @@ export default class VoxelSpace {
         return this.dims.slice();
     }
     getRaw() {
-        return this.space;
+        return this.space.slice();
     }
     // [1, 0,  0]   [x]   [ x]
     // [0, 0, -1] * [y] = [-z]
@@ -212,24 +219,21 @@ export default class VoxelSpace {
         return this.dims[0] * this.dims[2] * (this.dims[1] - 1 - y) + this.dims[2] * x + z;
     }
     at(x, y, z) {
-        const mask = 1n << BigInt(this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
-        return (this.space & mask) !== 0n;
+        return this.space[this.index(x, y, z)];
+    }
+    index(x, y, z) {
+        return this.dims[1] * this.dims[2] * x + this.dims[2] * y + z;
     }
     toggle(x, y, z) {
-        const mask = BigInt(1 << this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
-        this.space ^= mask;
+        const index = this.index(x, y, z);
+        this.space[index] = !this.space[index];
     }
     set(x, y, z, val) {
-        const mask = BigInt(1 << this.dims[1] * this.dims[2] * x + this.dims[2] * y + z);
-        if (val) {
-            this.space |= mask;
-        }
-        else {
-            this.space &= ~mask;
-        }
+        this.space[this.index(x, y, z)] = val;
     }
     rotated90(dim) {
-        let newSpace = 0n;
+        const newSpace = new Array(this.dims[0] * this.dims[1] * this.dims[2]);
+        newSpace.fill(false);
         let newDims;
         let rotIndex;
         if (dim === 'x') {
@@ -246,10 +250,10 @@ export default class VoxelSpace {
         }
         this.forEachCell((val, i, j, k) => {
             if (val) {
-                newSpace |= BigInt(1 << rotIndex(i, j, k));
+                newSpace[rotIndex(i, j, k)] = true;
             }
         });
-        return new VoxelSpace(this.id, newDims, newSpace);
+        return new VoxelSpaceBoolean({ id: this.id, dims: newDims, space: newSpace, color: this.color, cullEmpty: false });
     }
     rot90(dim) {
         const rot = this.rotated90(dim);
@@ -257,9 +261,21 @@ export default class VoxelSpace {
         this.dims = rot.getDims();
     }
     plus(space) {
-        const otherSpace = space.getRaw();
-        if ((this.space | otherSpace) === (this.space ^ otherSpace)) {
-            return new VoxelSpace(this.id, this.dims, otherSpace | this.space);
+        const newSpace = new Array(this.dims[0] * this.dims[1] * this.dims[2]);
+        newSpace.fill(false);
+        let clash = false;
+        space.forEachCell((val, x, y, z) => {
+            if (this.at(x, y, z) !== val) {
+                newSpace[this.index(x, y, z)] = true;
+            }
+            else {
+                if (val) {
+                    clash = true;
+                }
+            }
+        });
+        if (!clash) {
+            return new VoxelSpaceBoolean({ id: this.id, dims: this.getDims(), space: newSpace, color: this.color, cullEmpty: false });
         }
         return null;
     }
@@ -272,4 +288,34 @@ export default class VoxelSpace {
         });
         return size;
     }
+    getDirectNeighbourProfile(x, y, z) {
+        let result = 0;
+        if (x < this.dims[0] - 1 && this.at(x + 1, y, z)) {
+            result += 1;
+        }
+        if (y < this.dims[1] - 1 && this.at(x, y + 1, z)) {
+            result += 2;
+        }
+        if (z < this.dims[2] - 1 && this.at(x, y, z + 1)) {
+            result += 4;
+        }
+        if (x > 0 && this.at(x - 1, y, z)) {
+            result += 8;
+        }
+        if (y > 0 && this.at(x, y - 1, z)) {
+            result += 16;
+        }
+        if (z > 0 && this.at(x, y, z - 1)) {
+            result += 32;
+        }
+        return result;
+    }
+    getAllPermutationsInPrism(prismDimX, prismDimY, prismDimZ) {
+        const rotations = this.getUniqueRotations();
+        let result = new Array();
+        for (let i = 0; i < rotations.length; i++) {
+            result = result.concat(rotations[i].getAllPositionsInPrism(prismDimX, prismDimY, prismDimZ));
+        }
+        return result;
+    }
 }
diff --git a/src/solver/js/VoxelSpaceBoolean.ts b/src/solver/js/VoxelSpaceBoolean.ts
new file mode 100644
index 0000000..d529260
--- /dev/null
+++ b/src/solver/js/VoxelSpaceBoolean.ts
@@ -0,0 +1,364 @@
+export type DimensionDef = [number, number, number];
+
+const enum NeighbourDirection {
+    POSX,
+    POSY,
+    POSZ,
+    NEGX,
+    NEGY,
+    NEGZ,
+}
+
+export default class VoxelSpaceBoolean {
+    private dims: DimensionDef;
+    private length: number;
+    private space: boolean[];
+    private id: number;
+    private color: string;
+
+    constructor(options: {id: number, dims: DimensionDef, space?: boolean[] | bigint, cullEmpty: boolean, color?: string}) {
+        this.length = options.dims[0] * options.dims[1] * options.dims[2];
+        if (!options.space) {
+            options.space = new Array<boolean>(options.dims[0] * options.dims[1] * options.dims[2]);
+            options.space.fill(false);
+        } else if (!Array.isArray(options.space)) {
+            const newSpace = [];
+            for (let i = 0; i < this.length; i++) {
+                const mask = 1n << BigInt(i);
+                newSpace.push((options.space & mask) !== 0n);
+            }
+            options.space = newSpace;
+        }
+        this.id = options.id;
+        this.dims = options.dims;
+        this.space = options.space;
+        this.color = options.color ?? "red";
+        if (options.cullEmpty !== false) {
+            this.cullEmptySpace();
+        }
+    }
+
+    setColor(color: string) {
+        this.color = color;
+    }
+
+    getColor() {
+        return this.color;
+    }
+
+    binaryRep() {
+        return this.space.reduce((prev, curr) => prev + (curr ? "1" : "0"), "");
+    }
+
+    getExtrema() {
+        const extrema = {
+            xMax: 0,
+            xMin: this.dims[0],
+            yMax: 0,
+            yMin: this.dims[1],
+            zMax: 0,
+            zMin: this.dims[2],
+        };
+        this.forEachCell((val, x, y, z) => {
+            if (val) {
+                extrema.xMax = Math.max(extrema.xMax, x);
+                extrema.xMin = Math.min(extrema.xMin, x);
+                extrema.yMax = Math.max(extrema.yMax, y);
+                extrema.yMin = Math.min(extrema.yMin, y);
+                extrema.zMax = Math.max(extrema.zMax, z);
+                extrema.zMin = Math.min(extrema.zMin, z);
+            }
+        });
+        return extrema;
+    }
+
+    cullEmptySpace() {
+        const extrema = this.getExtrema();
+        const newX = extrema.xMax - extrema.xMin + 1;
+        const newY = extrema.yMax - extrema.yMin + 1;
+        const newZ = extrema.zMax - extrema.zMin + 1;
+        const newSpace = new Array<boolean>(newX * newY * newZ);
+        newSpace.fill(false);
+        let index = 0;
+        for (let x = extrema.xMin; x <= extrema.xMax; x++) {
+            for (let y = extrema.yMin; y <= extrema.yMax; y++) {
+                for (let z = extrema.zMin; z <= extrema.zMax; z++) {
+                    if (this.at(x, y, z)) {
+                        newSpace[index] = true;
+                    }
+                    index++;
+                }
+            }
+        }
+        this.dims[0] = newX;
+        this.dims[1] = newY;
+        this.dims[2] = newZ;
+        this.space = newSpace;
+    }
+
+    forEachCell(cb: (val: boolean, x: number, y: number, z: number) => any) {
+        loopStart: for (let x = 0; x < this.dims[0]; x++) {
+            for (let y = 0; y < this.dims[1]; y++) {
+                for (let z = 0; z < this.dims[2]; z++) {
+                    if (cb(this.at(x, y, z), x, y, z) === 0) {
+                        break loopStart;
+                    }
+                }
+            }
+        }
+    }
+
+    getId() {
+        return this.id;
+    }
+
+    print() {
+        let accum = "";
+        console.log("---");
+        for (let i = 0; i < this.dims[0]; i++) {
+            for (let j = 0; j < this.dims[1]; j++) {
+                for (let k = 0; k < this.dims[2]; k++) {
+                    accum += this.at(i, j, k) ? '#' : 'O';
+                }
+                console.log(accum);
+                accum = "";
+            }
+            if (i !== this.dims[0] - 1) {
+                console.log("-");
+            }
+        }
+        console.log("---");
+    }
+
+    getUniqueRotations() {
+        const rotations: VoxelSpaceBoolean[] = [];
+        const refSpace = this.clone();
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('z');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        refSpace.rot90('z');
+        refSpace.rot90('z');
+        VoxelSpaceBoolean.pushNewUniqueSpaces(rotations, refSpace.getAxisSpins('x'));
+        return rotations;
+    }
+
+    getAllRotations() {
+        const rotations: VoxelSpaceBoolean[] = [];
+        const refSpace = this.clone();
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('y');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('z');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        refSpace.rot90('z');
+        refSpace.rot90('z');
+        rotations.push(...refSpace.getAxisSpins('x'));
+        return rotations;
+    }
+
+    protected static pushNewUniqueSpaces(existingSpaces: VoxelSpaceBoolean[], newSpaces: VoxelSpaceBoolean[]) {
+        for (const newSpace of newSpaces) {
+            let matchFound = false;
+            for (const existingSpace of existingSpaces) {
+                if (newSpace.matches(existingSpace)) {
+                    matchFound = true;
+                    break;
+                }
+            }
+            if (!matchFound) {
+                existingSpaces.push(newSpace);
+            }
+        }
+    }
+
+    getAllPositionsInPrism(cubeDimX: number, cubeDimY: number, cubeDimZ: number): VoxelSpaceBoolean[] {
+        const cubePositions: VoxelSpaceBoolean[] = [];
+        if (this.dims[0] > cubeDimX || this.dims[1] > cubeDimY || this.dims[2] > cubeDimZ) {
+            return cubePositions;
+        }
+        for (let xOffset = 0; xOffset < (cubeDimX - this.dims[0] + 1); xOffset++) {
+            for (let yOffset = 0; yOffset < (cubeDimY - this.dims[1] + 1); yOffset++) {
+                for (let zOffset = 0; zOffset < (cubeDimZ - this.dims[2] + 1); zOffset++) {
+                    const cubePos = new VoxelSpaceBoolean({id: this.id, dims: [cubeDimX, cubeDimY, cubeDimZ], color: this.color, cullEmpty: false});
+                    this.forEachCell((val, x, y, z) => {
+                        cubePos.set(xOffset + x, yOffset + y, zOffset + z, val);
+                    });
+                    cubePositions.push(cubePos);
+                }
+            }
+        }
+        return cubePositions;
+    }
+
+    matches(space: VoxelSpaceBoolean) {
+        const otherDims = space.getDims();
+        for (let i = 0; i < this.dims.length; i++) {
+            if (otherDims[i] !== this.dims[i]) {
+                return false;
+            }
+        }
+        const otherRaw = space.getRaw();
+        if (typeof otherRaw === "bigint") {
+            return space.binaryRep() === this.binaryRep();
+        }
+        return this.space.reduce((prev, unit, i) => (unit === otherRaw[i]) && prev, true);
+    }
+
+    clone() {
+        return new VoxelSpaceBoolean({id: this.id, dims: this.getDims(), space: this.getRaw(), color: this.getColor(), cullEmpty: false});
+    }
+
+    private getAxisSpins(axis: 'x' | 'y' | 'z'): VoxelSpaceBoolean[] {
+        const rotations = [this.clone()];
+        for (let i = 0; i < 3; i++) {
+            rotations.push(rotations[i].rotated90(axis));
+        }
+        return rotations;
+    }
+
+    getDims(): DimensionDef {
+        return this.dims.slice() as DimensionDef;
+    }
+
+    getRaw() {
+        return this.space.slice();
+    }
+
+    // [1, 0,  0]   [x]   [ x]
+    // [0, 0, -1] * [y] = [-z]
+    // [0, 1,  0]   [z]   [ y]
+    private newIndexRotX(x: number, y: number, z: number) {
+        return this.dims[2] * this.dims[1] * x + this.dims[1] * (this.dims[2] - 1 - z) + y;
+    }
+
+    // [ 0, 0, 1]   [x]   [ z]
+    // [ 0, 1, 0] * [y] = [ y]
+    // [-1, 0, 0]   [z]   [-x]
+    private newIndexRotY(x: number, y: number, z: number) {
+        return this.dims[1] * this.dims[0] * z + this.dims[0] * y + (this.dims[0] - 1 - x);
+    }
+
+    // [0, -1, 0]     [x]   [-y]
+    // [1,  0, 0]  *  [y] = [ x]
+    // [0,  0, 1]     [z]   [ z]
+    private newIndexRotZ(x: number, y: number, z: number) {
+        return this.dims[0] * this.dims[2] * (this.dims[1] - 1 - y) + this.dims[2] * x + z;
+    }
+
+    at(x: number, y: number, z: number) {
+        return this.space[this.index(x, y, z)];
+    }
+
+    private index(x: number, y: number, z: number) {
+        return this.dims[1] * this.dims[2] * x + this.dims[2] * y + z;
+    }
+
+    toggle(x: number, y: number, z: number) {
+        const index = this.index(x, y, z);
+        this.space[index] = !this.space[index];
+    }
+
+    set(x: number, y: number, z: number, val: boolean) {
+        this.space[this.index(x, y, z)] = val;
+    }
+
+    rotated90(dim: 'x' | 'y' | 'z') {
+        const newSpace = new Array<boolean>(this.dims[0] * this.dims[1] * this.dims[2]);
+        newSpace.fill(false);
+        let newDims: DimensionDef;
+        let rotIndex: (i: number, j: number, k: number) => number;
+        if (dim === 'x') {
+            newDims = [this.dims[0], this.dims[2], this.dims[1]];
+            rotIndex = this.newIndexRotX.bind(this);
+        } else if (dim === 'y') {
+            newDims = [this.dims[2], this.dims[1], this.dims[0]];
+            rotIndex = this.newIndexRotY.bind(this);
+        } else {
+            newDims = [this.dims[1], this.dims[0], this.dims[2]];
+            rotIndex = this.newIndexRotZ.bind(this);
+        }
+        this.forEachCell((val, i, j, k) => {
+            if (val) {
+                newSpace[rotIndex(i, j, k)] = true;
+            }
+        })
+        return new VoxelSpaceBoolean({id: this.id, dims: newDims, space: newSpace, color: this.color, cullEmpty: false});
+    }
+
+    rot90(dim: 'x' | 'y' | 'z') {
+        const rot = this.rotated90(dim);
+        this.space = rot.getRaw();
+        this.dims = rot.getDims();
+    }
+
+    plus(space: VoxelSpaceBoolean): VoxelSpaceBoolean | null {
+        const newSpace = new Array<boolean>(this.dims[0] * this.dims[1] * this.dims[2]);
+        newSpace.fill(false);
+        let clash = false;
+        space.forEachCell((val, x, y, z) => {
+            if (this.at(x, y, z) !== val) {
+                newSpace[this.index(x, y, z)] = true;
+            } else {
+                if (val) {
+                    clash = true;
+                }
+            }
+        });
+        if (!clash) {
+            return new VoxelSpaceBoolean({id: this.id, dims: this.getDims(), space: newSpace, color: this.color, cullEmpty: false});
+        }
+        return null;
+    }
+
+    size() {
+        let size = 0;
+        this.forEachCell((val) => {
+            if (val) {
+                size++;
+            }
+        });
+        return size;
+    }
+
+    getDirectNeighbourProfile(x: number, y: number, z: number): number {
+        let result = 0;
+        if (x < this.dims[0] - 1 && this.at(x + 1, y, z)) {
+            result += 1;
+        }
+        if (y < this.dims[1] - 1 && this.at(x, y + 1, z)) {
+            result += 2;
+        }
+        if (z < this.dims[2] - 1 && this.at(x, y, z + 1)) {
+            result += 4;
+        }
+        if (x > 0 && this.at(x - 1, y, z)) {
+            result += 8;
+        }
+        if (y > 0 && this.at(x, y - 1, z)) {
+            result += 16;
+        }
+        if (z > 0 && this.at(x, y, z - 1)) {
+            result += 32;
+        }
+        return result;
+    }
+
+    getAllPermutationsInPrism(prismDimX: number, prismDimY: number, prismDimZ: number): VoxelSpaceBoolean[] {
+        const rotations = this.getUniqueRotations();
+        let result = new Array<VoxelSpaceBoolean>();
+        for (let i = 0; i < rotations.length; i++) {
+            result = result.concat(rotations[i].getAllPositionsInPrism(prismDimX, prismDimY, prismDimZ));
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/src/solver/js/main.js b/src/solver/js/main.js
new file mode 100644
index 0000000..cfc2cb1
--- /dev/null
+++ b/src/solver/js/main.js
@@ -0,0 +1,16 @@
+import SomaSolver from "./SomaSolver";
+import VoxelSpaceBoolean from "./VoxelSpaceBoolean";
+export function solve(polycubes, dimX, dimY, dimZ) {
+    const solver = new SomaSolver(dimX, dimY, dimZ);
+    const voxelSpaces = new Array();
+    for (let i = 0; i < polycubes.length; i++) {
+        voxelSpaces.push(new VoxelSpaceBoolean({
+            id: i,
+            dims: [dimX, dimY, dimZ],
+            space: polycubes[i],
+            cullEmpty: true
+        }));
+    }
+    solver.solve(voxelSpaces);
+    return solver.getSolutions();
+}
diff --git a/src/solver/js/main.ts b/src/solver/js/main.ts
new file mode 100644
index 0000000..94363d3
--- /dev/null
+++ b/src/solver/js/main.ts
@@ -0,0 +1,18 @@
+import SomaSolver from "./SomaSolver";
+import VoxelSpaceBoolean from "./VoxelSpaceBoolean";
+import type SomaSolution from "./SomaSolution";
+
+export function solve(polycubes: bigint[], dimX: number, dimY: number, dimZ: number): SomaSolution[] {
+    const solver = new SomaSolver(dimX, dimY, dimZ);
+    const voxelSpaces = new Array<VoxelSpaceBoolean>();
+    for (let i = 0; i < polycubes.length; i++) {
+        voxelSpaces.push(new VoxelSpaceBoolean({
+            id: i,
+            dims: [dimX, dimY, dimZ],
+            space: polycubes[i],
+            cullEmpty: true
+        }));
+    }
+    solver.solve(voxelSpaces);
+    return solver.getSolutions();
+}
\ No newline at end of file
diff --git a/src/solver/js/package.json b/src/solver/js/package.json
new file mode 100644
index 0000000..026ddfe
--- /dev/null
+++ b/src/solver/js/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "soma-solve-js",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.ts",
+  "scripts": {
+    "build": "npx tsc main.ts --target ES2020 --moduleResolution node"
+  },
+  "author": "Daniel Ledda",
+  "license": "ISC"
+}
diff --git a/src/solver/asconfig.json b/src/solver/wasm/asconfig.json
similarity index 75%
rename from src/solver/asconfig.json
rename to src/solver/wasm/asconfig.json
index af6a46f..55aa624 100644
--- a/src/solver/asconfig.json
+++ b/src/solver/wasm/asconfig.json
@@ -7,8 +7,8 @@
       "debug": true
     },
     "release": {
-      "binaryFile": "../../public/solver/main.wasm",
-      "textFile": "../../public/solver/main.wat",
+      "binaryFile": "../../../public/solver/main.wasm",
+      "textFile": "../../../public/solver/main.wat",
       "sourceMap": false,
       "optimizeLevel": 3,
       "shrinkLevel": 1,
diff --git a/src/solver/assembly/SomaSolution.ts b/src/solver/wasm/assembly/SomaSolution.ts
similarity index 86%
rename from src/solver/assembly/SomaSolution.ts
rename to src/solver/wasm/assembly/SomaSolution.ts
index 422ce95..b513bf4 100644
--- a/src/solver/assembly/SomaSolution.ts
+++ b/src/solver/wasm/assembly/SomaSolution.ts
@@ -2,12 +2,14 @@ import VoxelSpace from "./VoxelSpace";
 
 export default class SomaSolution {
     private solutionSpaces: VoxelSpace[];
-    private dim: i32;
-    constructor(dim: i32) {
-        if (dim < 0 || dim % 1 !== 0) {
-            throw new Error("Dimension must be a whole positive integer!");
-        }
-        this.dim = dim;
+    private dimX: i32;
+    private dimY: i32;
+    private dimZ: i32;
+
+    constructor(dimX: i32, dimY: i32, dimZ: i32) {
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
         this.solutionSpaces = [];
     }
 
@@ -42,7 +44,7 @@ export default class SomaSolution {
         }
         const allRots: VoxelSpace[][] = this.solutionSpaces.map<VoxelSpace[]>(space => space.getAllRotations());
         for (let i = 0; i < allRots[0].length; i++) {
-            const solnRot = new SomaSolution(this.dim);
+            const solnRot = new SomaSolution(this.dimX, this.dimY, this.dimZ);
             for (let j = 0; j < allRots.length; j++) {
                 solnRot.addSpace(allRots[j][i]);
             }
@@ -74,15 +76,11 @@ export default class SomaSolution {
     }
 
     clone(): SomaSolution {
-        const clone = new SomaSolution(this.dim);
+        const clone = new SomaSolution(this.dimX, this.dimY, this.dimZ);
         clone.solutionSpaces = this.solutionSpaces.slice(0, this.solutionSpaces.length);
         return clone;
     }
 
-    getDims(): i32[] {
-        return [this.dim, this.dim, this.dim];
-    }
-
     getPieces(): VoxelSpace[] {
         return this.solutionSpaces;
     }
diff --git a/src/solver/assembly/SomaSolver.ts b/src/solver/wasm/assembly/SomaSolver.ts
similarity index 67%
rename from src/solver/assembly/SomaSolver.ts
rename to src/solver/wasm/assembly/SomaSolver.ts
index a123ef0..cd3196b 100644
--- a/src/solver/assembly/SomaSolver.ts
+++ b/src/solver/wasm/assembly/SomaSolver.ts
@@ -3,34 +3,30 @@ import SomaSolution from "./SomaSolution";
 
 export default class SomaSolver {
     private solutionCube: VoxelSpace;
-    private dim: i32;
+    private dimX: i32;
+    private dimY: i32;
+    private dimZ: i32;
     private solutions: SomaSolution[] = new Array<SomaSolution>();
-    private iterations: i32 = 0;
-    constructor(dimension: i32) {
-        if (dimension % 1 !== 0 || dimension < 0) {
-            throw new Error("The argument 'dimension' must be a positive whole number");
-        }
-        this.dim = dimension;
-        this.solutionCube = new VoxelSpace(0, dimension, dimension, dimension, 0);
+    constructor(dimX: i32, dimY: i32, dimZ: i32) {
+        this.dimX = dimX;
+        this.dimY = dimY;
+        this.dimZ = dimZ;
+        this.solutionCube = new VoxelSpace(0, dimX, dimY, dimZ, 0);
     }
 
     solve(polycubes: VoxelSpace[]): void {
         if (polycubes.length === 0) {
             throw new Error("You must pass at least one polycube to solve the puzzle.");
         }
-        let cumulativeSize = polycubes.reduce((prev, curr) => prev + curr.size(), 0);
-        if (cumulativeSize !== this.dim**3) {
-            throw new Error(`The polycubes passed do not add up to exactly enough units to form a cube of dimension ${this.dim}! Got: ${cumulativeSize}, need: ${this.dim**3}`);
-        }
         this.solutions.splice(0, this.solutions.length);
         const combosWithRots: VoxelSpace[][] = new Array<Array<VoxelSpace>>();
         for (let i = 1; i < polycubes.length; i++) {
-            combosWithRots.push(polycubes[i].getAllPermutationsInCubeOfSize(this.dim));
+            combosWithRots.push(polycubes[i].getAllPermutationsInPrism(this.dimX, this.dimY, this.dimZ));
         }
         let combos: VoxelSpace[][] = new Array<Array<VoxelSpace>>();
-        combos.push(polycubes[0].getAllPositionsInCube(this.dim));
+        combos.push(polycubes[0].getAllPositionsInPrism(this.dimX, this.dimY, this.dimZ));
         combos = combos.concat(combosWithRots);
-        this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dim));
+        this.backtrackSolve(this.solutionCube, combos, new SomaSolution(this.dimX, this.dimY, this.dimZ));
         this.solutions = SomaSolution.filterUnique(this.solutions);
     }
 
@@ -47,7 +43,7 @@ export default class SomaSolver {
                 nextSoln.addSpace(nextCubeGroup[i]);
                 if (polycubes.length == 1) {
                     this.solutions.push(nextSoln);
-                    currentSoln = new SomaSolution(this.dim);
+                    currentSoln = new SomaSolution(this.dimX, this.dimY, this.dimZ);
                     return;
                 } else {
                     this.backtrackSolve(fusionAttempt, polycubes.slice(1), nextSoln, depth + 1);
diff --git a/src/solver/assembly/VoxelSpace.ts b/src/solver/wasm/assembly/VoxelSpace.ts
similarity index 67%
rename from src/solver/assembly/VoxelSpace.ts
rename to src/solver/wasm/assembly/VoxelSpace.ts
index 1c26a80..542efaf 100644
--- a/src/solver/assembly/VoxelSpace.ts
+++ b/src/solver/wasm/assembly/VoxelSpace.ts
@@ -13,19 +13,16 @@ export default class VoxelSpace {
     private length: i32;
     private space: i64;
     private id: i32;
-    private dimx: i32;
-    private dimy: i32;
-    private dimz: i32;
+    private dimX: i32;
+    private dimY: i32;
+    private dimZ: i32;
 
     constructor(id: i32, dimx: i32, dimy: i32, dimz: i32, space: i64 = 0, cullEmpty: boolean = false) {
-        if (!space) {
-            space = 0;
-        }
         this.id = id;
         this.length = dimx * dimy * dimz;
-        this.dimx = dimx;
-        this.dimy = dimy;
-        this.dimz = dimz;
+        this.dimX = dimx;
+        this.dimY = dimy;
+        this.dimZ = dimz;
         this.space = space;
         if (cullEmpty) {
             this.cullEmptySpace();
@@ -35,15 +32,15 @@ export default class VoxelSpace {
     getExtrema(): Extrema {
         const extrema = new Extrema(
             0,
-            i32.MAX_VALUE,
+            this.dimX,
             0,
-            i32.MAX_VALUE,
+            this.dimY,
             0,
-            i32.MAX_VALUE,
+            this.dimZ,
         );
-        for (let x = 0; x < this.dimx; x++) {
-            for (let y = 0; y < this.dimy; y++) {
-                for (let z = 0; z < this.dimz; z++) {
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
                     const val = this.at(x, y, z);
                     if (val) {
                         extrema.xMax = Math.max(extrema.xMax, x) as i32;
@@ -61,8 +58,8 @@ export default class VoxelSpace {
 
     private cullEmptySpace(): void {
         const extrema = this.getExtrema();
-        let index = 0;
-        let newSpace = 0;
+        let index: i32 = 0;
+        let newSpace: i64 = 0;
         for (let x = extrema.xMin; x <= extrema.xMax; x++) {
             for (let y = extrema.yMin; y <= extrema.yMax; y++) {
                 for (let z = extrema.zMin; z <= extrema.zMax; z++) {
@@ -73,9 +70,9 @@ export default class VoxelSpace {
                 }
             }
         }
-        this.dimx = extrema.xMax - extrema.xMin + 1;
-        this.dimy = extrema.yMax - extrema.yMin + 1;
-        this.dimz = extrema.zMax - extrema.zMin + 1;
+        this.dimX = extrema.xMax - extrema.xMin + 1;
+        this.dimY = extrema.yMax - extrema.yMin + 1;
+        this.dimZ = extrema.zMax - extrema.zMin + 1;
         this.space = newSpace;
     }
 
@@ -134,45 +131,44 @@ export default class VoxelSpace {
         }
     }
 
-    getAllPositionsInCube(cubeDim: i32): VoxelSpace[] {
-        if ((cubeDim > 0) && (cubeDim % 1 == 0)) {
-            const cubePositions: VoxelSpace[] = [];
-            for (let x = 0; x < cubeDim - this.dimx + 1; x++) {
-                for (let y = 0; y < cubeDim - this.dimy + 1; y++) {
-                    for (let z = 0; z < cubeDim - this.dimz + 1; z++) {
-                        const cubePos = new VoxelSpace(this.id, cubeDim, cubeDim, cubeDim);
-                        for (let rotX = 0; rotX < this.dimx; rotX++) {
-                            for (let rotY = 0; rotY < this.dimy; rotY++) {
-                                for (let rotZ = 0; rotZ < this.dimz; rotZ++) {
-                                    cubePos.set(x + rotX, y + rotY, z + rotZ, this.at(rotX, rotY, rotZ));
-                                }
+    getAllPositionsInPrism(cubeDimX: i32, cubeDimY: i32, cubeDimZ: i32): VoxelSpace[] {
+        const cubePositions: VoxelSpace[] = [];
+        if (this.dimX > cubeDimX || this.dimY > cubeDimY || this.dimZ > cubeDimZ) {
+            return cubePositions;
+        }
+        for (let x = 0; x < (cubeDimX - this.dimX + 1); x++) {
+            for (let y = 0; y < (cubeDimY - this.dimY + 1); y++) {
+                for (let z = 0; z < (cubeDimZ - this.dimZ + 1); z++) {
+                    const cubePos = new VoxelSpace(this.id, cubeDimX, cubeDimY, cubeDimZ);
+                    for (let posX = 0; posX < this.dimX; posX++) {
+                        for (let posY = 0; posY < this.dimY; posY++) {
+                            for (let posZ = 0; posZ < this.dimZ; posZ++) {
+                                cubePos.set(x + posX, y + posY, z + posZ, this.at(posX, posY, posZ));
                             }
                         }
-                        cubePositions.push(cubePos);
                     }
+                    cubePositions.push(cubePos);
                 }
             }
-            return cubePositions;
-        } else {
-            throw new Error("cubeDim must be a positive integer.");
         }
+        return cubePositions;
     }
 
     matches(space: VoxelSpace): boolean {
-        if (space.dimx !== this.dimx) {
+        if (space.dimX !== this.dimX) {
             return false;
         }
-        if (space.dimy !== this.dimy) {
+        if (space.dimY !== this.dimY) {
             return false;
         }
-        if (space.dimz !== this.dimz) {
+        if (space.dimZ !== this.dimZ) {
             return false;
         }
         return this.space == space.getRaw();
     }
 
     clone(): VoxelSpace {
-        return new VoxelSpace(this.id, this.dimx, this.dimy, this.dimz, this.getRaw());
+        return new VoxelSpace(this.id, this.dimX, this.dimY, this.dimZ, this.getRaw());
     }
 
     private getXAxisSpins(): VoxelSpace[] {
@@ -192,35 +188,35 @@ export default class VoxelSpace {
     // [0, 0, -1] * [y] = [-z]
     // [0, 1,  0]   [z]   [ y]
     private newIndexRotX(x: i32, y: i32, z: i32): i32 {
-        return this.dimz * this.dimy * x + this.dimy * (this.dimz - 1 - z) + y;
+        return this.dimZ * this.dimY * x + this.dimY * (this.dimZ - 1 - z) + y;
     }
 
     // [ 0, 0, 1]   [x]   [ z]
     // [ 0, 1, 0] * [y] = [ y]
     // [-1, 0, 0]   [z]   [-x]
     private newIndexRotY(x: i32, y: i32, z: i32): i32 {
-        return this.dimy * this.dimx * z + this.dimx * y + (this.dimx - 1 - x);
+        return this.dimY * this.dimX * z + this.dimX * y + (this.dimX - 1 - x);
     }
 
     // [0, -1, 0]     [x]   [-y]
     // [1,  0, 0]  *  [y] = [ x]
     // [0,  0, 1]     [z]   [ z]
     private newIndexRotZ(x: i32, y: i32, z: i32): i32 {
-        return this.dimx * this.dimz * (this.dimy - 1 - y) + this.dimz * x + z;
+        return this.dimX * this.dimZ * (this.dimY - 1 - y) + this.dimZ * x + z;
     }
 
     at(x: i32, y: i32, z: i32): boolean {
-        const mask = 1 << (this.dimy * this.dimz * x + this.dimz * y + z);
+        const mask = 1 << (this.dimY * this.dimZ * x + this.dimZ * y + z);
         return (this.space & mask) !== 0;
     }
 
     toggle(x: i32, y: i32, z: i32): void {
-        const mask = 1 << this.dimy * this.dimz * x + this.dimz * y + z;
+        const mask = 1 << this.dimY * this.dimZ * x + this.dimZ * y + z;
         this.space ^= mask;
     }
 
     set(x: i32, y: i32, z: i32, val: boolean): void {
-        const mask = 1 << this.dimy * this.dimz * x + this.dimz * y + z;
+        const mask = 1 << this.dimY * this.dimZ * x + this.dimZ * y + z;
         if (val) {
             this.space |= mask;
         } else {
@@ -230,83 +226,83 @@ export default class VoxelSpace {
 
     rotated90X(): VoxelSpace {
         let newSpace = 0;
-        for (let x = 0; x < this.dimx; x++) {
-            for (let y = 0; y < this.dimy; y++) {
-                for (let z = 0; z < this.dimz; z++) {
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
                     if (this.at(x, y, z)) {
                         newSpace |= 1 << this.newIndexRotX(x, y, z);
                     }
                 }
             }
         }
-        return new VoxelSpace(this.id, this.dimx, this.dimz, this.dimy, newSpace);
+        return new VoxelSpace(this.id, this.dimX, this.dimZ, this.dimY, newSpace);
     }
 
     rotated90Y(): VoxelSpace {
         let newSpace = 0;
-        for (let x = 0; x < this.dimx; x++) {
-            for (let y = 0; y < this.dimy; y++) {
-                for (let z = 0; z < this.dimz; z++) {
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
                     if (this.at(x, y, z)) {
                         newSpace |= 1 << this.newIndexRotY(x, y, z);
                     }
                 }
             }
         }
-        return new VoxelSpace(this.id, this.dimz, this.dimy, this.dimx, newSpace);
+        return new VoxelSpace(this.id, this.dimZ, this.dimY, this.dimX, newSpace);
     }
 
     rotated90Z(): VoxelSpace {
         let newSpace = 0;
-        for (let x = 0; x < this.dimx; x++) {
-            for (let y = 0; y < this.dimy; y++) {
-                for (let z = 0; z < this.dimz; z++) {
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
                     if (this.at(x, y, z)) {
                         newSpace |= 1 << this.newIndexRotZ(x, y, z);
                     }
                 }
             }
         }
-        return new VoxelSpace(this.id, this.dimy, this.dimx, this.dimz, newSpace);
+        return new VoxelSpace(this.id, this.dimY, this.dimX, this.dimZ, newSpace);
     }
 
     rot90X(): void {
         const rot = this.rotated90X();
         this.space = rot.getRaw();
-        this.dimx = rot.dimx;
-        this.dimy = rot.dimy;
-        this.dimz = rot.dimz;
+        this.dimX = rot.dimX;
+        this.dimY = rot.dimY;
+        this.dimZ = rot.dimZ;
     }
 
     rot90Y(): void {
         const rot = this.rotated90Y();
         this.space = rot.getRaw();
-        this.dimx = rot.dimx;
-        this.dimy = rot.dimy;
-        this.dimz = rot.dimz;
+        this.dimX = rot.dimX;
+        this.dimY = rot.dimY;
+        this.dimZ = rot.dimZ;
     }
 
     rot90Z(): void {
         const rot = this.rotated90Z();
         this.space = rot.getRaw();
-        this.dimx = rot.dimx;
-        this.dimy = rot.dimy;
-        this.dimz = rot.dimz;
+        this.dimX = rot.dimX;
+        this.dimY = rot.dimY;
+        this.dimZ = rot.dimZ;
     }
 
     plus(space: VoxelSpace): VoxelSpace | null {
         const otherSpace = space.getRaw();
         if ((this.space | otherSpace) == (this.space ^ otherSpace)) {
-            return new VoxelSpace(this.id, this.dimx, this.dimy, this.dimz, otherSpace | this.space);
+            return new VoxelSpace(this.id, this.dimX, this.dimY, this.dimZ, otherSpace | this.space);
         }
         return null;
     }
 
     size(): i32 {
         let size = 0;
-        for (let x = 0; x < this.dimx; x++) {
-            for (let y = 0; y < this.dimy; y++) {
-                for (let z = 0; z < this.dimz; z++) {
+        for (let x = 0; x < this.dimX; x++) {
+            for (let y = 0; y < this.dimY; y++) {
+                for (let z = 0; z < this.dimZ; z++) {
                     if (this.at(x, y, z)) {
                         size++;
                     }
@@ -316,11 +312,11 @@ export default class VoxelSpace {
         return size;
     }
 
-    getAllPermutationsInCubeOfSize(dim: i32): VoxelSpace[] {
+    getAllPermutationsInPrism(prismDimX: i32, prismDimY: i32, prismDimZ: i32): VoxelSpace[] {
         const rotations = this.getUniqueRotations();
         let result = new Array<VoxelSpace>();
         for (let i = 0; i < rotations.length; i++) {
-            result = result.concat(rotations[i].getAllPositionsInCube(dim));
+            result = result.concat(rotations[i].getAllPositionsInPrism(prismDimX, prismDimY, prismDimZ));
         }
         return result;
     }
diff --git a/src/solver/assembly/index.ts b/src/solver/wasm/assembly/index.ts
similarity index 72%
rename from src/solver/assembly/index.ts
rename to src/solver/wasm/assembly/index.ts
index 941163b..62a1100 100644
--- a/src/solver/assembly/index.ts
+++ b/src/solver/wasm/assembly/index.ts
@@ -2,11 +2,11 @@ import SomaSolver from "./SomaSolver";
 import VoxelSpace from "./VoxelSpace";
 
 
-export function solve(polycubes: Array<i64>, dim: i32): Int64Array[] {
-    const solver = new SomaSolver(dim);
+export function solve(polycubes: Array<i64>, dimX: i32, dimY: i32, dimZ: i32): Int64Array[] {
+    const solver = new SomaSolver(dimX, dimY, dimZ);
     const voxelSpaces = new Array<VoxelSpace>();
     for (let i = 0; i < polycubes.length; i++) {
-        voxelSpaces.push(new VoxelSpace(i, dim, dim, dim, polycubes[i], true));
+        voxelSpaces.push(new VoxelSpace(i, dimX, dimY, dimZ, polycubes[i], true));
     }
     solver.solve(voxelSpaces);
     const solutions = solver.getSolutions();
diff --git a/src/solver/assembly/tsconfig.json b/src/solver/wasm/assembly/tsconfig.json
similarity index 100%
rename from src/solver/assembly/tsconfig.json
rename to src/solver/wasm/assembly/tsconfig.json
diff --git a/src/solver/index.js b/src/solver/wasm/index.js
similarity index 94%
rename from src/solver/index.js
rename to src/solver/wasm/index.js
index 0c1fe49..88c1a8a 100644
--- a/src/solver/index.js
+++ b/src/solver/wasm/index.js
@@ -6,7 +6,7 @@ const asyncTask = async () => {
 
     // You can now use your wasm / as-bind instance!
     const response = asBindInstance.exports.solve(
-        [16875584n, 16810176n, 65688n, 77952n, 12296n, 2109456n, 4184n], 3
+        [16875584n, 16810176n, 65688n, 77952n, 12296n, 2109456n, 4184n], 3, 3, 3
     );
     console.log(response); // AsBind: Hello World!
 };
diff --git a/src/solver/package-lock.json b/src/solver/wasm/package-lock.json
similarity index 100%
rename from src/solver/package-lock.json
rename to src/solver/wasm/package-lock.json
diff --git a/src/solver/package.json b/src/solver/wasm/package.json
similarity index 57%
rename from src/solver/package.json
rename to src/solver/wasm/package.json
index 3d8fcfc..ccf108b 100644
--- a/src/solver/package.json
+++ b/src/solver/wasm/package.json
@@ -1,7 +1,7 @@
 {
   "scripts": {
-    "asbuild:untouched": "asc assembly/index.ts --target debug",
-    "asbuild:optimized": "asc assembly/index.ts --target release",
+    "asbuild:untouched": "asc assembly/index.ts --exportRuntime --transform as-bind --target debug",
+    "asbuild:optimized": "asc assembly/index.ts --exportRuntime --transform as-bind --target release",
     "asbuild": "npm run asbuild:untouched && npm run asbuild:optimized",
     "test": "node tests"
   },
diff --git a/src/store.ts b/src/store.ts
index b45981e..4028363 100644
--- a/src/store.ts
+++ b/src/store.ts
@@ -1,111 +1,119 @@
 import { derived, writable } from 'svelte/store';
 import { get } from 'svelte/store';
-import type SomaSolution from "./SomaSolution";
+import SomaSolution from "./SomaSolution";
+import VoxelSpaceBigInt from "./VoxelSpaceBigInt";
+import type {DimensionDef} from "./VoxelSpaceBoolean";
 
-type PolycubeInput = {
-    color: string,
-    rep: bigint,
-}
-
-const MAX_DIMS = 5;
-const MIN_DIMS = 2;
-
-const store = {
-    polycubes: writable<PolycubeInput[]>([{rep: BigInt(0), color: colorFromIndex(0)}]),
-    somaDimension: writable(3), 
-};
+const MAX_DIMS = 20;
+const MIN_DIMS = 1;
 
+export const solving = writable(false);
+export const debug = writable(false);
+export const somaDimX = dimStore(3);
+export const somaDimY = dimStore(3);
+export const somaDimZ = dimStore(3);
+export const polycubes = polycubeStore();
 export const selectedCube = writable(0);
-export const isMaxDimension = derived(store.somaDimension, ($somaDimension: number) => $somaDimension >= MAX_DIMS);
-export const isMinDimension = derived(store.somaDimension, ($somaDimension: number) => $somaDimension <= MIN_DIMS);
-export const isMaxPolycubes = derived(
-    [store.polycubes, store.somaDimension],
-    ([$polycubes, $somaDimension]: [PolycubeInput[], number]) => $polycubes.length >= $somaDimension ** 3);
-export const isMinPolycubes = derived(store.polycubes, ($polycubes: PolycubeInput[]) => $polycubes.length <= 1);
 export const solutions = writable([] as SomaSolution[]);
 export const activeSolution = writable<number | null>(null);
 export const showingSolution = writable(false);
+export const totalVolume = derived(
+    [somaDimX, somaDimY, somaDimZ],
+    ([$dimX, $dimY, $dimZ]: [number, number, number]) => $dimX*$dimY*$dimZ
+);
+export const isMaxPolycubes = derived(
+    [polycubes, totalVolume],
+    ([$cubes, $vol]: [VoxelSpaceBigInt[], number]) => $cubes.length >= $vol
+);
+export const isMinPolycubes = derived(
+    polycubes,
+    ($polycubes: VoxelSpaceBigInt[]) => $polycubes.length <= 1
+);
 
-export const somaDimension = {
-    subscribe: store.somaDimension.subscribe,
-    inc() {
-        if (!get(isMaxDimension)) {
-            store.somaDimension.update((dims: number) => {
-                polycubes.reset(dims + 1);
-                return dims + 1;
-            });
-        }
-    },
-    dec() {
-        if (!get(isMinDimension)) {
-            store.somaDimension.update((dims: number) => {
-                polycubes.reset(dims - 1);
-                return dims - 1;
-            });
-        }
-    },
-    set(dims: number) {
-        if (dims <= MAX_DIMS && dims >= MIN_DIMS) {
-            polycubes.reset(dims);
-            store.somaDimension.set(dims);
-        }
-    }
-};
-
-export const polycubes = {
-    subscribe: store.polycubes.subscribe,
-    addCube() {
-        const isMaxPolycubes = get(store.polycubes).length >= get(store.somaDimension) ** 3;
-        if (!isMaxPolycubes) {
-            store.polycubes.update((polycubes: PolycubeInput[]) => polycubes.concat({
-                rep: BigInt(0),
-                color: colorFromIndex(polycubes.length),
-            }));
-        }
-    },
-    removeCube() {
-        const isMinPolycubes = get(store.polycubes).length <= 1;
-        if (!isMinPolycubes) {
-            store.polycubes.update((polycubes: PolycubeInput[]) => polycubes.splice(0, polycubes.length - 1));
-        }
-        const newLength = get(store.polycubes).length;
-        if (newLength <= get(selectedCube)) {
-            selectedCube.set(newLength - 1);
-        }
-    },
-    toggle(cubeIndex: number, x: number, y: number, z: number) {
-        const dims = get(store.somaDimension);
-        const mask = BigInt(1) << BigInt(dims ** 2 * x + dims * y + z);
-        const cubes = get(store.polycubes);
-        cubes[cubeIndex].rep ^= mask;
-        store.polycubes.set(cubes);
-    },
-    set(cubeIndex: number, val: boolean, x: number, y: number, z: number) {
-        const dims = get(store.somaDimension);
-        const mask = BigInt(1) << BigInt(dims ** 2 * x + dims * y + z);
-        const cubes = get(store.polycubes);
-        if (val) {
-            cubes[cubeIndex].rep |= mask
-        } else {
-            cubes[cubeIndex].rep &= ~mask
-        }
-        store.polycubes.set(cubes);
-    },
-    reset(dims: number) {
-        store.polycubes.update((polycubes: PolycubeInput[]) => {
-            const result: PolycubeInput[] = [];
-            for (let i = 0; i < Math.min(polycubes.length, dims**3); i++) {
-                result.push({
-                    rep: BigInt(0),
-                    color: colorFromIndex(i),
-                });
+function dimStore(init: number) {
+    const dimStore = writable(init);
+    return {
+        subscribe: dimStore.subscribe,
+        set(dim: number) {
+            if (dim > MAX_DIMS || dim < MIN_DIMS) {
+                return;
             }
-            return result;
+            dimStore.set(dim);
+            polycubes.reset();
+        },
+    }
+}
+
+function polycubeStore() {
+    function freshCube(id: number) {
+        return new VoxelSpaceBigInt({
+            id: id,
+            dims: [get(somaDimX), get(somaDimY), get(somaDimZ)],
+            color: colorFromIndex(id),
+            cullEmpty: false
         });
     }
-};
+    const polycubeStore = writable<VoxelSpaceBigInt[]>([freshCube(0)]);
+    return {
+        subscribe: polycubeStore.subscribe,
+        setColor(cubeIndex: number, color: string) {
+            const cubes = get(polycubeStore);
+            cubes[cubeIndex].setColor(color);
+            polycubeStore.set(cubes);
+        },
+        addCube() {
+            if (!get(isMaxPolycubes)) {
+                polycubeStore.update((polycubes: VoxelSpaceBigInt[]) =>
+                    polycubes.concat(freshCube(polycubes.length)));
+            }
+        },
+        removeCube() {
+            if (!get(isMinPolycubes)) {
+                polycubeStore.update((polycubes: VoxelSpaceBigInt[]) => polycubes.splice(0, polycubes.length - 1));
+            }
+            const newLength = get(polycubeStore).length;
+            if (newLength <= get(selectedCube)) {
+                selectedCube.set(newLength - 1);
+            }
+        },
+        toggle(cubeIndex: number, x: number, y: number, z: number) {
+            const cubes = get(polycubeStore);
+            cubes[cubeIndex].toggle(x, y, z);
+            polycubeStore.set(cubes);
+        },
+        set(cubeIndex: number, val: boolean, x: number, y: number, z: number) {
+            const cubes = get(polycubeStore);
+            cubes[cubeIndex].set(x, y, z, val);
+            polycubeStore.set(cubes);
+        },
+        reset() {
+            polycubeStore.update((polycubes: VoxelSpaceBigInt[]) => {
+                const result: VoxelSpaceBigInt[] = [];
+                for (let i = 0; i < Math.min(polycubes.length, get(totalVolume)); i++) {
+                    result.push(freshCube(i));
+                }
+                return result;
+            });
+        }
+    }
+}
 
-function colorFromIndex(index: number) {
+function rgbToHex(rgbStr: string): string {
+    const sep = rgbStr.indexOf(",") > -1 ? "," : " ";
+    const rgb = rgbStr.substr(4).split(")")[0].split(sep);
+    const r = (+rgb[0]).toString(16).padStart(2, "0");
+    const g = (+rgb[1]).toString(16).padStart(2, "0");
+    const b = (+rgb[2]).toString(16).padStart(2, "0");
+    return "#" + r + g + b;
+}
+
+function hslToRgb(hslStr: string): string {
+    const opt = new Option();
+    opt.style.color = hslStr;
+    return opt.style.color;
+}
+
+export function colorFromIndex(index: number): string {
     const colorWheelCycle = Math.floor(index / 6);
     const darknessCycle = Math.floor(index / 12);
     const spacing = (360 / 6);
@@ -113,5 +121,121 @@ function colorFromIndex(index: number) {
     let hue = spacing * (index % 6) + offset;
     const saturation = 100;
     const lightness = 1 / (2 + darknessCycle) * 100;
-    return `hsl(${hue},${saturation}%,${Math.round(lightness)}%)`;
-}    
\ No newline at end of file
+    return rgbToHex(hslToRgb(`hsl(${hue},${saturation}%,${Math.round(lightness)}%)`));
+}
+
+const worker = new Worker('../solver/main.js', {type: "module"});
+async function respondWasm(event: MessageEvent) {
+    solutions.set(event.data.map((wasmSolution) => {
+        const solnObj = new SomaSolution(get(somaDimX), get(somaDimY), get(somaDimZ));
+        const spaceReps = wasmSolution.split(",");
+        for (let i = 0; i < spaceReps.length; i++) {
+            solnObj.addSpace(new VoxelSpaceBigInt({
+                id: i,
+                dims: [get(somaDimX), get(somaDimY), get(somaDimZ)] as DimensionDef,
+                space: BigInt(parseInt(spaceReps[i])),
+                color: get(polycubes)[i].getColor(),
+                cullEmpty: false,
+            }));
+        }
+        return solnObj;
+    }));
+    if (event.data.length > 0) {
+        activeSolution.set(0);
+        showingSolution.set(true);
+    } else {
+        showingSolution.set(false);
+        activeSolution.set(null);
+    }
+    solving.set(false);
+}
+
+function respondJs(event: MessageEvent) {
+    solutions.set(event.data.solns.map(solnSpaces => {
+        const solnObj = new SomaSolution(get(somaDimX), get(somaDimY), get(somaDimZ));
+        for (let i = 0; i < solnSpaces.length; i++) {
+            solnObj.addSpace(new VoxelSpaceBigInt({
+                id: i,
+                dims: [get(somaDimX), get(somaDimY), get(somaDimZ)] as DimensionDef,
+                space: BigInt(`0b${ solnSpaces[i] }`),
+                color: get(polycubes)[i].getColor(),
+                cullEmpty: false,
+            }));
+        }
+        return solnObj;
+    }));
+    if (event.data.length > 0) {
+        activeSolution.set(0);
+        showingSolution.set(true);
+    } else {
+        showingSolution.set(false);
+        activeSolution.set(null);
+    }
+    solving.set(false);
+}
+
+export function solve() {
+    const doWasm = get(totalVolume) <= 32;
+    let inputCubes;
+    if (doWasm) {
+        worker.onmessage = (e) => respondWasm(e);
+    } else {
+        worker.onmessage = (e) => respondJs(e);
+    }
+    inputCubes = get(polycubes).map(cubeInput => cubeInput.getRaw());
+    solving.set(true);
+    worker.postMessage({
+        type: doWasm ? 'wasm' : 'js',
+        polycubes: inputCubes,
+        dimX: get(somaDimX),
+        dimY: get(somaDimY),
+        dimZ: get(somaDimZ)
+    });
+}
+
+// async function solveSync() {
+//     const solver = new SomaSolver(get(somaDimX), get(somaDimY), get(somaDimZ));
+//     function showSolutionWaitUserFeedback(soln: SomaSolution) {
+//         activeSolution.set(0);
+//         solutions.set([soln]);
+//         showingSolution.set(true);
+//         return new Promise<void>((resolve) => {
+//             const callback = (e: KeyboardEvent) => {
+//                 resolve();
+//                 window.removeEventListener("keydown", callback);
+//             };
+//             window.addEventListener("keydown", callback);
+//         });
+//     }
+//     if (get(debug)) {
+//         solver.setDebug({
+//             showSoln(soln: SomaSolution) {
+//                 return showSolutionWaitUserFeedback(soln);
+//             },
+//             showSpace(cube: VoxelSpaceBoolean) {
+//                 const testSoln = new SomaSolution(get(somaDimX), get(somaDimY), get(somaDimZ));
+//                 testSoln.addSpace(cube);
+//                 return showSolutionWaitUserFeedback(testSoln);
+//             }
+//         });
+//     }
+//     solving.set(true);
+//     await solver.solve(get(polycubes).map(cubeInput => new VoxelSpaceBoolean({
+//         id: cubeInput.getId(),
+//         dims: cubeInput.getDims(),
+//         space: cubeInput.getRaw(),
+//         color: cubeInput.getColor(),
+//         cullEmpty: true
+//     })));
+//     const solns = solver.getSolutions();
+//
+//     if (solns.length > 0) {
+//         activeSolution.set(0);
+//         solutions.set(solns);
+//         showingSolution.set(true);
+//     } else {
+//         showingSolution.set(false);
+//         activeSolution.set(null);
+//     }
+//     solving.set(false);
+// }
\ No newline at end of file
diff --git a/src/ui/CubeInput.svelte b/src/ui/CubeInput.svelte
index 10a63e4..3234213 100644
--- a/src/ui/CubeInput.svelte
+++ b/src/ui/CubeInput.svelte
@@ -1,24 +1,24 @@
 <script lang="ts">
-    import {somaDimension, polycubes, selectedCube, showingSolution} from "../store";
+    import {somaDimX, somaDimY, somaDimZ, polycubes, selectedCube, showingSolution} from "../store";
+    import VoxelSpaceBoolean from "../VoxelSpaceBoolean";
     export let cubeNo: number;
 
-    $: dimension = $somaDimension;
-    $: cube = $polycubes[cubeNo];
-    $: cubeColor = cube.color;
+    $: cube = $polycubes[cubeNo] as VoxelSpaceBoolean;
+    $: cubeColor = cube.getColor();
     $: currentlyVisualised = $selectedCube === cubeNo && !$showingSolution;
     let cellStartDragInitialVal: boolean = false;
     let cellStartDrag: number = 0;
     let cellDragStartPos: {x: number, y: number} = {x: 0, y: 0};
     let cellEndDrag: number = 0;
     let cellDragEndPos: {x: number, y: number} = {x: 0, y: 0};
+    let picker: HTMLInputElement;
 
     function cellNo(x: number, y: number, z: number) {
-        return dimension ** 2 * x + dimension * y + z;
+        return $somaDimY * $somaDimZ * x + $somaDimZ * y + z;
     }
 
-    function at(rep: bigint, x: number, y: number, z: number) {
-        const mask = BigInt(1) << BigInt(cellNo(x, y, z));
-        return (rep & mask) !== BigInt(0);
+    function at(cube: VoxelSpaceBoolean, x: number, y: number, z: number) {
+        return cube.at(x, y, z);
     }
 
     function onMouseOverCell(event: MouseEvent, x: number, y: number, z: number) {
@@ -30,7 +30,7 @@
 
     function onMouseDownCell(event: MouseEvent, x: number, y: number, z: number) {
         cellStartDrag = cellNo(x, y, z);
-        cellStartDragInitialVal = at(cube.rep, x, y, z);
+        cellStartDragInitialVal = at(cube, x, y, z);
         cellDragStartPos.x = event.clientX;
         cellDragStartPos.y = event.clientY;
     }
@@ -56,29 +56,43 @@
 
     function onClickCube() {
         showingSolution.set(false);
-        selectedCube.set(cubeNo)
+        selectedCube.set(cubeNo);
+    }
+
+    function onColorChange(event: InputEvent) {
+        polycubes.setColor(cubeNo, event.target.value);
     }
 </script>
 
 <div
     class="cube"
     class:active={currentlyVisualised}
-    style="--color: {cubeColor}; --dimension: {dimension};"
+    style="--color: {cubeColor};"
     on:contextmenu|preventDefault
     on:mousedown={onClickCube}
 >
-    <h1>Cube: {cubeNo + 1}</h1>
-    {#each {length: dimension} as _, x}
+    <div class="header">
+        <h1>Cube: {cubeNo + 1}</h1>
+        <div class="colorPickerBtn" on:click={picker.click()}>
+            <input
+                bind:this={picker}
+                class="colorPicker"
+                type="color"
+                value="{cubeColor}"
+                on:change={(event) => onColorChange(event)}/>
+        </div>
+    </div>
+    {#each {length: $somaDimX} as _, x}
         <div class="layer">
-            {#each {length: dimension} as _, y}
+            {#each {length: $somaDimY} as _, y}
                 <div class="row">
-                {#each {length: dimension} as _, z}
+                {#each {length: $somaDimZ} as _, z}
                     <div
                         class="cell"
-                        class:filled={at(cube.rep, z, dimension-1-x, y)}
-                        on:mousemove={(event) => onMouseOverCell(event, z, dimension-1-x, y)}
-                        on:mousedown={(event) => onMouseDownCell(event, z, dimension-1-x, y)}
-                        on:mouseup={(event) => onMouseUpCell(event, z, dimension-1-x, y)}
+                        class:filled={at(cube, x, y, z)}
+                        on:mousemove={(event) => onMouseOverCell(event, x, y, z)}
+                        on:mousedown={(event) => onMouseDownCell(event, x, y, z)}
+                        on:mouseup={(event) => onMouseUpCell(event, x, y, z)}
                     />
                 {/each}
                 </div>
@@ -91,6 +105,27 @@
     * {
         --cell-size: 30px;
     }
+    .header {
+        text-align: center;
+        display: flex;
+        align-content: center;
+        justify-content: space-between;
+    }
+    .header > * {
+        display: inline-block;
+    }
+    .colorPicker {
+        visibility: hidden;
+        width: 0;
+        height: 0;
+    }
+    .colorPickerBtn {
+        align-self: center;
+        background-image: url("../resources/ColorWheel.png");
+        background-size: cover;
+        width: 1.5em;
+        height: 1.5em;
+    }
     .cube.active {
         border: 3px solid #ff3e00;
     }
@@ -125,6 +160,8 @@
     }
     .row {
         display: flex;
+        align-content: center;
+        justify-content: center;
         margin: 0;
     }
     .layer {
diff --git a/src/ui/Sidebar.svelte b/src/ui/Sidebar.svelte
index 64e70a1..45f9eb6 100644
--- a/src/ui/Sidebar.svelte
+++ b/src/ui/Sidebar.svelte
@@ -1,8 +1,13 @@
 <script lang="ts">
-    import {isMaxPolycubes, isMinPolycubes, somaDimension, polycubes, solutions} from "../store";
-    import SomaSolution from "../SomaSolution";
+    import {
+        isMaxPolycubes,
+        isMinPolycubes,
+        polycubes,
+        solutions,
+        colorFromIndex,
+        activeSolution, showingSolution, totalVolume, somaDimX, somaDimY, somaDimZ, debug
+    } from "../store";
     import SolutionList from "./SolutionList.svelte";
-    import VoxelSpace from "../VoxelSpace";
 
     $: numCubes = $polycubes.length;
     $: cubes = $polycubes;
@@ -11,57 +16,16 @@
     let readyToSolve: boolean;
     let size: number;
     $: {
-        const dim = $somaDimension as number;
-        const polycubes: VoxelSpace[] = cubes.map(cubeInput => new VoxelSpace(0, [dim, dim, dim], cubeInput.rep));
-        size = polycubes.reduce((prev, cube) => cube.size() + prev, 0);
-        noEmpties = polycubes.reduce((prev, cube) => (cube.size() !== 0) && prev, true);
-        enoughSubcubes = size === dim**3;
-        readyToSolve = size === dim**3 && noEmpties;
-    }
-    let solving = false;
-    const worker = new Worker('../solver/main.js', {type: "module"});
-
-    async function respondWasm(event: MessageEvent) {
-        const dim = $somaDimension as number;
-        solutions.set(event.data.map((wasmSolution) => {
-            const solnObj = new SomaSolution(dim);
-            const spaceReps = wasmSolution.split(",");
-            for (let i = 0; i < spaceReps.length; i++) {
-                solnObj.addSpace(new VoxelSpace(i, [dim, dim, dim], BigInt(parseInt(spaceReps[i]))));
-            }
-            return solnObj;
-        }));
-        solving = false;
-    }
-
-    function respondJs(event: MessageEvent) {
-        solutions.set(event.data.map(solnData => {
-            const solution = new SomaSolution(solnData.dim);
-            solnData.solutionSpaces.forEach((voxelSpace, i) => solution.addSpace(new VoxelSpace(i, [solnData.dim, solnData.dim, solnData.dim], voxelSpace.space)));
-            return solution;
-        }));
-        solving = false;
-    }
-
-    function solveJs() {
-        worker.onmessage = (e) => respondJs(e);
-        const polycubes = cubes.map(cubeInput => cubeInput.rep);
-        solving = true;
-        worker.postMessage({type: 'js', polycubes, dims: $somaDimension});
-    }
-
-    function solveWasm() {
-        worker.onmessage = (e) => respondWasm(e);
-        const polycubes = cubes.map(cubeInput => cubeInput.rep);
-        console.log(polycubes);
-        solving = true;
-        worker.postMessage({type: 'wasm', polycubes, dims: $somaDimension});
+        size = cubes.reduce((prev, cube) => cube.size() + prev, 0);
+        noEmpties = cubes.reduce((prev, cube) => (cube.size() !== 0) && prev, true);
+        enoughSubcubes = size === $totalVolume;
+        readyToSolve = enoughSubcubes && noEmpties;
     }
 
     function genTooltip() {
         let messages = [];
         if (!enoughSubcubes) {
-            messages.push(`You have not input enough subcubes to form a cube with a side length of ${$somaDimension}. Needed: ${$somaDimension**3}, current: ${size}.`);
+            messages.push(`You have not input enough subcubes to form a rectangular prism with side lengths ${$somaDimX}, ${$somaDimY}, and ${$somaDimZ}. Needed: ${$totalVolume}, current: ${size}.`);
         }
         if (!noEmpties) {
             messages.push("You have left some of the polycube inputs empty. Remove them to solve.");
@@ -74,34 +38,34 @@
     <h1>Somaesque</h1>
     <div class="widgets">
         <div class="option">
-            <p>Dimension:</p>
+            <p>Dimensions:</p>
             <div class="choice">
-                <button
-                    class:selected={$somaDimension === 2}
-                    on:click={() => somaDimension.set(2)}
-                    disabled={$somaDimension === 2}>
-                    2
-                </button>
-                <button
-                    class:selected={$somaDimension === 3}
-                    on:click={() => somaDimension.set(3)}
-                    disabled={$somaDimension === 3}>
-                    3
-                </button>
-                <button
-                    class:selected={$somaDimension === 4}
-                    on:click={() => somaDimension.set(4)}
-                    disabled={$somaDimension === 4}>
-                    4
-                </button>
+                X
+                <input
+                    type="number"
+                    value="3"
+                    on:input={(e) => somaDimX.set(e.target.valueAsNumber)}/>
+                Y
+                <input
+                    type="number"
+                    value="3"
+                    on:input={(e) => somaDimY.set(e.target.valueAsNumber)}/>
+                Z
+                <input
+                    type="number"
+                    value="3"
+                    on:input={(e) => somaDimZ.set(e.target.valueAsNumber)}/>
+                {#if $totalVolume > 32}
+                    <p class="warn">The total number of units exceeds 32. Attempting to solve puzzles with more than 32 units results in significantly slower computation time.</p>
+                {/if}
             </div>
         </div>
 
         <div class="option">
             <p>Cubes:</p>
             <div class="choice">
-                <p>{numCubes}</p>
                 <button on:click={polycubes.removeCube} disabled={$isMinPolycubes}>-</button>
+                <p>{numCubes}</p>
                 <button on:click={polycubes.addCube} disabled={$isMaxPolycubes}>+</button>
             </div>
         </div>
@@ -109,7 +73,7 @@
         <div class="option">
             <button
                 class="solve"
-                on:click={solveWasm}
+                on:click={solve}
                 title="{genTooltip(enoughSubcubes, noEmpties, size)}"
                 disabled="{solving || !readyToSolve}">
                 {solving ? "Solving..." : "Solve!"}
@@ -121,6 +85,9 @@
 </div>
 
 <style>
+    .warn {
+        color: red;
+    }
     p {
         margin: 0;
         display: inline-block;
@@ -130,10 +97,10 @@
         text-align: center;
         margin-top: 1em;
     }
-    button {
+    input {
         display: inline-block;
         background-color: #999999;
-        width: 2em;
+        width: 3em;
         height: 2em;
         border-style: none;
     }
diff --git a/src/ui/Solution2D.svelte b/src/ui/Solution2D.svelte
index 812c4c3..4fecc53 100644
--- a/src/ui/Solution2D.svelte
+++ b/src/ui/Solution2D.svelte
@@ -1,12 +1,12 @@
 <script lang="ts">
-    import {polycubes, activeSolution, showingSolution, solutions} from "../store";
+    import {activeSolution, showingSolution, solutions} from "../store";
     import SomaSolution from "../SomaSolution";
 
-    $: solutionDisplayed = $solutions[$activeSolution];
-    $: dimension = (solutionDisplayed && solutionDisplayed.getDims?.()[0]) ?? 3;
+    $: solnToShow = $solutions[$activeSolution];
+    $: dims = (solnToShow?.getDims?.()) ?? [3, 3, 3];
 
     function colorAt(soln: SomaSolution, x: number, y: number, z: number) {
-        return $polycubes[soln.at(z, dimension-1-x, y)].color;
+        return solnToShow.getPieces()[soln.at(x, y, z)]?.getColor?.() ?? "red";
     }
 </script>
 
@@ -14,19 +14,18 @@
     <div
         class="cube"
         class:active={$showingSolution}
-        style="--dimension: {dimension};"
         on:click={() => showingSolution.set(true)}
     >
         <h1>Solution #{$activeSolution + 1}</h1>
         <div class="center">
-            {#each {length: dimension} as _, x}
+            {#each {length: dims[0]} as _, x}
                 <div class="layer">
-                    {#each {length: dimension} as _, y}
+                    {#each {length: dims[1]} as _, y}
                         <div class="row">
-                            {#each {length: dimension} as _, z}
+                            {#each {length: dims[2]} as _, z}
                                 <div
                                     class="cell"
-                                    style="background-color:{colorAt(solutionDisplayed, x, y, z)}; border-color: {colorAt(solutionDisplayed, x, y, z)}"
+                                    style="background-color:{colorAt(solnToShow, x, y, z)}; border-color: {colorAt(solnToShow, x, y, z)}"
                                     class:filled={true}
                                 />
                             {/each}
diff --git a/src/ui/SolutionViewer.svelte b/src/ui/SolutionViewer.svelte
index c18b546..1560ed5 100644
--- a/src/ui/SolutionViewer.svelte
+++ b/src/ui/SolutionViewer.svelte
@@ -1,36 +1,49 @@
 <script lang="ts">
-    import PolycubeScene from "./threedee/PolycubeScene.ts";
+    import PolycubeScene from "./threedee/PolycubeScene";
     import {onMount} from "svelte";
-    import {polycubes, somaDimension, selectedCube, solutions, activeSolution, showingSolution} from "../store";
+    import {polycubes, selectedCube, solutions, activeSolution, showingSolution, somaDimX, somaDimY, somaDimZ} from "../store";
     import Solution2D from "./Solution2D.svelte";
+    import VoxelSpaceBoolean from "../VoxelSpaceBoolean";
 
     $: cube = $polycubes[$selectedCube];
     $: soln = $solutions[$activeSolution];
     let el: HTMLCanvasElement;
-    let threeTest: PolycubeScene;
+    let scene: PolycubeScene;
     let loaded: boolean = false;
 
     onMount(() => {
-        threeTest = new PolycubeScene(el, () => loaded = true, console.log);
+        scene = new PolycubeScene(el, () => loaded = true, console.log);
     });
 
+    window.getPermutations = () => {
+        const newCube: VoxelSpaceBoolean = cube.clone() as VoxelSpaceBoolean;
+        (newCube as VoxelSpaceBoolean).cullEmptySpace();
+        return (newCube as VoxelSpaceBoolean).getAllPermutationsInPrism($somaDimX, $somaDimY, $somaDimZ);
+    }
+
+    window.showRot = (rot: VoxelSpaceBoolean) => {
+        scene?.showPolycube(rot);
+    }
+
     $: {
         if (loaded) {
             if ($showingSolution) {
                 const colorMap = {};
                 $polycubes.forEach((polycube, i) => colorMap[i] = polycube.color);
-                threeTest?.showSolution(soln, colorMap);
+                scene?.showSolution(soln);
             } else {
-                threeTest?.showPolycube(cube.rep, $somaDimension, cube.color);
+                scene?.showPolycube(cube);
             }
         }
     }
 </script>
 
 <div class="top">
-    <div class="soln2d-container">
-        <Solution2D/>
-    </div>
+    {#if $activeSolution !== null}
+        <div class="soln2d-container">
+            <Solution2D/>
+        </div>
+    {/if}
     <canvas
         bind:this={el}
         width="640"
diff --git a/src/ui/threedee/PolycubeMesh.ts b/src/ui/threedee/PolycubeMesh.ts
index d466d7b..c75dc15 100644
--- a/src/ui/threedee/PolycubeMesh.ts
+++ b/src/ui/threedee/PolycubeMesh.ts
@@ -1,20 +1,20 @@
 import * as THREE from "three";
-import type VoxelSpace from "../../VoxelSpace";
+import type VoxelSpaceBoolean from "../../VoxelSpaceBoolean";
 import type GeometryManager from "./GeometryManager";
+import type VoxelSpaceBigInt from "../../VoxelSpaceBigInt";
 
 export default class PolycubeMesh {
     private static geometryManager: GeometryManager;
     private group: THREE.Group;
     private meshes: THREE.Mesh[] = [];
-    private currentPolycube: bigint = 0n;
+    private currentPolycube: boolean[] | bigint = [];
     private material: THREE.MeshPhongMaterial;
     private numActiveCubes: number = 0;
     private flyDirection: THREE.Vector3 = new THREE.Vector3();
 
-    constructor(polycube: VoxelSpace, color: string) {
-        this.material = new THREE.MeshPhongMaterial({color: 'red', shininess: 100, reflectivity: 100});
+    constructor(polycube: VoxelSpaceBoolean | VoxelSpaceBigInt) {
+        this.material = new THREE.MeshPhongMaterial({color: polycube.getColor(), shininess: 100, reflectivity: 100});
         this.group = new THREE.Group();
-        this.swapColor(color);
         this.swapPolycube(polycube);
     }
 
@@ -22,11 +22,7 @@ export default class PolycubeMesh {
         PolycubeMesh.geometryManager = manager;
     }
 
-    swapColor(color: string) {
-        this.material.color.set(color);
-    }
-
-    swapPolycube(polycube: VoxelSpace) {
+    swapPolycube(polycube: VoxelSpaceBoolean | VoxelSpaceBigInt) {
         if (polycube.getRaw() === this.currentPolycube) {
             return;
         }
@@ -40,10 +36,11 @@ export default class PolycubeMesh {
             }
         });
         this.currentPolycube = polycube.getRaw();
+        this.material.color.set(polycube.getColor());
         this.flyDirection = this.middlePosOfGroup().normalize();
     }
 
-    private addCube(refPolycube: VoxelSpace, x: number, y: number, z: number) {
+    private addCube(refPolycube: VoxelSpaceBoolean | VoxelSpaceBigInt, x: number, y: number, z: number) {
         const dims = refPolycube.getDims();
         const neighbourProfile = refPolycube.getDirectNeighbourProfile(x, y, z);
         const mesh = new THREE.Mesh(
@@ -51,9 +48,9 @@ export default class PolycubeMesh {
             this.material
         );
         mesh.position.set(
-            -((dims[0] - 1)/2) + x,
-            -((dims[1] - 1)/2) + y,
             -((dims[2] - 1)/2) + z,
+            ((dims[0] - 1)/2) - x,
+            -((dims[1] - 1)/2) + y,
         );
         this.meshes.push(mesh);
         this.group.add(mesh);
diff --git a/src/ui/threedee/PolycubeScene.ts b/src/ui/threedee/PolycubeScene.ts
index 00d99ba..1ab05aa 100644
--- a/src/ui/threedee/PolycubeScene.ts
+++ b/src/ui/threedee/PolycubeScene.ts
@@ -2,7 +2,8 @@ import * as THREE from 'three';
 import type SomaSolution from "../../SomaSolution";
 import RotationControl from "./RotationControl";
 import PolycubeMesh from "./PolycubeMesh";
-import VoxelSpace, {DimensionDef} from "../../VoxelSpace";
+import type VoxelSpaceBoolean from "../../VoxelSpaceBoolean";
+import type VoxelSpaceBigInt from "../../VoxelSpaceBigInt";
 import GeometryManager from "./GeometryManager";
 
 export default class PolycubeScene {
@@ -44,20 +45,19 @@ export default class PolycubeScene {
         this.camera.lookAt(0, 0, 0);
     }
 
-    private showPolycube(polycube: bigint, dims: number, color: string) {
+    showPolycube(voxelSpace: VoxelSpaceBoolean) {
         this.controls.disableFly();
-        const voxelSpace = new VoxelSpace(0, [dims, dims, dims], polycube, true);
         this.clearScene();
-        this.addPolycube(voxelSpace, color);
+        this.addPolycube(voxelSpace);
         this.polycubeMeshes[0].center();
     }
 
-    private showSolution(solution: SomaSolution, colorMap: Record<number, string>) {
+    showSolution(solution: SomaSolution) {
         this.controls.enableFly();
         this.clearScene();
         const pieces = solution.getPieces();
         for (let i = 0; i < pieces.length; i++) {
-            this.addPolycube(pieces[i], colorMap[i]);
+            this.addPolycube(pieces[i]);
         }
     }
 
@@ -66,8 +66,8 @@ export default class PolycubeScene {
         this.cubeScene.clear();
     }
 
-    private addPolycube(voxelSpace: VoxelSpace, color: string) {
-        const newMesh = new PolycubeMesh(voxelSpace, color);
+    private addPolycube(voxelSpace: VoxelSpaceBoolean | VoxelSpaceBigInt) {
+        const newMesh = new PolycubeMesh(voxelSpace);
         this.polycubeMeshes.push(newMesh);
         this.cubeScene.add(newMesh.asObj3D());
     }
diff --git a/tsconfig.json b/tsconfig.json
index 383e4af..062b0b4 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -5,5 +5,5 @@
     "target": "ESNext"
   },
   "include": ["./src/**/*"],
-  "exclude": ["./node_modules/*", "./__sapper__/*", "./public/*", "./src/solver/**/*"]
+  "exclude": ["./node_modules/*", "./__sapper__/*", "./public/*", "./src/solver/wasm/*"]
 }
\ No newline at end of file