85 files changed, 2506 insertions, 1078 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 853acc3ad..02f954083 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -227,15 +227,15 @@ SET_PROPERTY(TARGET asm2wasm PROPERTY CXX_STANDARD 11)
 SET_PROPERTY(TARGET asm2wasm PROPERTY CXX_STANDARD_REQUIRED ON)
 INSTALL(TARGETS asm2wasm DESTINATION ${CMAKE_INSTALL_BINDIR})
 
-SET(wasm2asm_SOURCES
-  src/tools/wasm2asm.cpp
+SET(wasm2js_SOURCES
+  src/tools/wasm2js.cpp
 )
-ADD_EXECUTABLE(wasm2asm
-               ${wasm2asm_SOURCES})
-TARGET_LINK_LIBRARIES(wasm2asm passes wasm asmjs emscripten-optimizer ir cfg support)
-SET_PROPERTY(TARGET wasm2asm PROPERTY CXX_STANDARD 11)
-SET_PROPERTY(TARGET wasm2asm PROPERTY CXX_STANDARD_REQUIRED ON)
-INSTALL(TARGETS wasm2asm DESTINATION ${CMAKE_INSTALL_BINDIR})
+ADD_EXECUTABLE(wasm2js
+               ${wasm2js_SOURCES})
+TARGET_LINK_LIBRARIES(wasm2js passes wasm asmjs emscripten-optimizer ir cfg support)
+SET_PROPERTY(TARGET wasm2js PROPERTY CXX_STANDARD 11)
+SET_PROPERTY(TARGET wasm2js PROPERTY CXX_STANDARD_REQUIRED ON)
+INSTALL(TARGETS wasm2js DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 SET(wasm-emscripten-finalize_SOURCES
   src/tools/wasm-emscripten-finalize.cpp
diff --git a/README.md b/README.md
index 98c66febb..05453e9e1 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Compilers built using Binaryen include
 
  * [`asm2wasm`](https://github.com/WebAssembly/binaryen/blob/master/src/asm2wasm.h) which compiles asm.js to WebAssembly
  * [`AssemblyScript`](https://github.com/AssemblyScript/assemblyscript) which compiles TypeScript to Binaryen IR
- * [`wasm2asm`](https://github.com/WebAssembly/binaryen/blob/master/src/wasm2asm.h) which compiles WebAssembly to asm.js
+ * [`wasm2js`](https://github.com/WebAssembly/binaryen/blob/master/src/wasm2js.h) which compiles WebAssembly to JS
  * [`Asterius`](https://github.com/tweag/asterius) which compiles Haskell to WebAssembly
 
 Binaryen also provides a set of **toolchain utilities** that can
@@ -64,7 +64,7 @@ This repository contains code that builds the following tools in `bin/`:
  * **wasm-dis**: Un-assembles WebAssembly in binary format into text format (going through Binaryen IR).
  * **wasm-opt**: Loads WebAssembly and runs Binaryen IR passes on it.
  * **asm2wasm**: An asm.js-to-WebAssembly compiler, using Emscripten's asm optimizer infrastructure. This is used by Emscripten in Binaryen mode when it uses Emscripten's fastcomp asm.js backend.
- * **wasm2asm**: A WebAssembly-to-asm.js compiler (still experimental).
+ * **wasm2js**: A WebAssembly-to-JS compiler (still experimental).
  * **wasm-merge**: Combines wasm files into a single big wasm file (without sophisticated linking).
  * **wasm-ctor-eval**: A tool that can execute C++ global constructors ahead of time. Used by Emscripten.
  * **wasm-emscripten-finalize**: Takes a wasm binary produced by llvm+lld and performs emscripten-specific passes over it.
@@ -212,11 +212,11 @@ This is separate from that. `asm2wasm` focuses on compiling asm.js to WebAssembl
 
 * How about compiling WebAssembly to asm.js (the opposite direction of `asm2wasm`)? Wouldn't that be useful for polyfilling?
 
-Experimentation with this is happening, in `wasm2asm`.
+Experimentation with this is happening, in `wasm2js`.
 
 This would be useful, but it is a much harder task, due to some decisions made in WebAssembly. For example, WebAssembly can have control flow nested inside expressions, which can't directly map to asm.js. It could be supported by outlining the code to another function, or to compiling it down into new basic blocks and control-flow-free instructions, but it is hard to do so in a way that is both fast to do and emits code that is fast to execute. On the other hand, compiling asm.js to WebAssembly is almost straightforward.
 
-We just have to do more work on `wasm2asm` and see how efficient we can make it.
+We just have to do more work on `wasm2js` and see how efficient we can make it.
 
 * Can `asm2wasm` compile any asm.js code?
 
diff --git a/auto_update_tests.py b/auto_update_tests.py
index a291421d5..4693351b1 100755
--- a/auto_update_tests.py
+++ b/auto_update_tests.py
@@ -22,10 +22,10 @@ import sys
 from scripts.test.support import run_command, split_wast, node_test_glue, node_has_webassembly
 from scripts.test.shared import (
     ASM2WASM, MOZJS, NODEJS, WASM_OPT, WASM_AS, WASM_DIS,
-    WASM_CTOR_EVAL, WASM_MERGE, WASM_REDUCE, WASM2ASM, WASM_METADCE,
+    WASM_CTOR_EVAL, WASM_MERGE, WASM_REDUCE, WASM2JS, WASM_METADCE,
     WASM_EMSCRIPTEN_FINALIZE, BINARYEN_INSTALL_DIR, BINARYEN_JS,
     files_with_pattern, has_shell_timeout, options)
-from scripts.test.wasm2asm import tests, spec_tests, extra_wasm2asm_tests, assert_tests, wasm2asm_dir
+from scripts.test.wasm2js import tests, spec_tests, extra_wasm2js_tests, assert_tests, wasm2js_dir, wasm2js_blacklist
 
 
 def update_asm_js_tests():
@@ -339,25 +339,28 @@ def update_ctor_eval_tests():
         o.write(actual)
 
 
-def update_wasm2asm_tests():
-  print '\n[ checking wasm2asm ]\n'
-  for wasm in tests + spec_tests + extra_wasm2asm_tests:
+def update_wasm2js_tests():
+  print '\n[ checking wasm2js ]\n'
+  for wasm in tests + spec_tests + extra_wasm2js_tests:
     if not wasm.endswith('.wast'):
       continue
 
+    if os.path.basename(wasm) in wasm2js_blacklist:
+      continue
+
     asm = os.path.basename(wasm).replace('.wast', '.2asm.js')
-    expected_file = os.path.join(wasm2asm_dir, asm)
+    expected_file = os.path.join(wasm2js_dir, asm)
 
-    # we run wasm2asm on tests and spec tests only if the output
+    # we run wasm2js on tests and spec tests only if the output
     # exists - only some work so far. the tests in extra are in
-    # the test/wasm2asm dir and so are specific to wasm2asm, and
+    # the test/wasm2js dir and so are specific to wasm2js, and
     # we run all of those.
-    if wasm not in extra_wasm2asm_tests and not os.path.exists(expected_file):
+    if wasm not in extra_wasm2js_tests and not os.path.exists(expected_file):
       continue
 
     print '..', wasm
 
-    cmd = WASM2ASM + [os.path.join('test', wasm)]
+    cmd = WASM2JS + [os.path.join('test', wasm)]
     out = run_command(cmd)
     with open(expected_file, 'w') as o:
       o.write(out)
@@ -370,7 +373,7 @@ def update_wasm2asm_tests():
     asserts_expected_file = os.path.join('test', asserts)
     traps_expected_file = os.path.join('test', traps)
 
-    cmd = WASM2ASM + [os.path.join(wasm2asm_dir, wasm), '--allow-asserts']
+    cmd = WASM2JS + [os.path.join(wasm2js_dir, wasm), '--allow-asserts']
     out = run_command(cmd)
     with open(asserts_expected_file, 'w') as o:
       o.write(out)
@@ -423,7 +426,7 @@ def main():
   update_wasm_merge_tests()
   update_binaryen_js_tests()
   update_ctor_eval_tests()
-  update_wasm2asm_tests()
+  update_wasm2js_tests()
   update_metadce_tests()
   update_reduce_tests()
 
diff --git a/check.py b/check.py
index f5e8b104a..907c14b16 100755
--- a/check.py
+++ b/check.py
@@ -31,7 +31,7 @@ from scripts.test.shared import (
 
 import scripts.test.asm2wasm as asm2wasm
 import scripts.test.lld as lld
-import scripts.test.wasm2asm as wasm2asm
+import scripts.test.wasm2js as wasm2js
 
 if options.interpreter:
   print '[ using wasm interpreter at "%s" ]' % options.interpreter
@@ -648,7 +648,7 @@ def main():
   run_spec_tests()
   run_binaryen_js_tests()
   lld.test_wasm_emscripten_finalize()
-  wasm2asm.test_wasm2asm()
+  wasm2js.test_wasm2js()
   run_validator_tests()
   if has_vanilla_emcc and has_vanilla_llvm and 0:
     run_vanilla_tests()
diff --git a/scripts/test/node-esm-loader.mjs b/scripts/test/node-esm-loader.mjs
new file mode 100644
index 000000000..73ff47800
--- /dev/null
+++ b/scripts/test/node-esm-loader.mjs
@@ -0,0 +1,32 @@
+// originally lifted from https://nodejs.org/api/esm.html
+
+import path from 'path';
+import process from 'process';
+import Module from 'module';
+
+const builtins = Module.builtinModules;
+
+const baseURL = new URL('file://');
+baseURL.pathname = `${process.cwd()}/`;
+
+export function resolve(specifier, parentModuleURL = baseURL, defaultResolve) {
+  if (builtins.includes(specifier)) {
+    return {
+      url: specifier,
+      format: 'builtin'
+    };
+  }
+  // Resolve the 'spectest' module to our special module which has some builtins
+  if (specifier == 'spectest') {
+    const resolved = new URL('./scripts/test/spectest.js', parentModuleURL);
+    return {
+      url: resolved.href,
+      format: 'esm'
+    };
+  }
+  const resolved = new URL(specifier, parentModuleURL);
+  return {
+    url: resolved.href,
+    format: 'esm'
+  };
+}
diff --git a/scripts/test/shared.py b/scripts/test/shared.py
index 309f3b59a..a7bdda085 100644
--- a/scripts/test/shared.py
+++ b/scripts/test/shared.py
@@ -166,7 +166,7 @@ WASM_OPT = [os.path.join(options.binaryen_bin, 'wasm-opt')]
 WASM_AS = [os.path.join(options.binaryen_bin, 'wasm-as')]
 WASM_DIS = [os.path.join(options.binaryen_bin, 'wasm-dis')]
 ASM2WASM = [os.path.join(options.binaryen_bin, 'asm2wasm')]
-WASM2ASM = [os.path.join(options.binaryen_bin, 'wasm2asm')]
+WASM2JS = [os.path.join(options.binaryen_bin, 'wasm2js')]
 WASM_CTOR_EVAL = [os.path.join(options.binaryen_bin, 'wasm-ctor-eval')]
 WASM_SHELL = [os.path.join(options.binaryen_bin, 'wasm-shell')]
 WASM_MERGE = [os.path.join(options.binaryen_bin, 'wasm-merge')]
diff --git a/scripts/test/spectest.js b/scripts/test/spectest.js
new file mode 100644
index 000000000..0756209b6
--- /dev/null
+++ b/scripts/test/spectest.js
@@ -0,0 +1,3 @@
+export function print(...args) {
+  console.log(...args);
+}
diff --git a/scripts/test/support.py b/scripts/test/support.py
index d04a85c59..5d03419b9 100644
--- a/scripts/test/support.py
+++ b/scripts/test/support.py
@@ -147,7 +147,7 @@ def split_wast(wastFile):
 
 
 def run_command(cmd, expected_status=0, stderr=None,
-                expected_err=None, err_contains=False):
+                expected_err=None, err_contains=False, err_ignore=None):
   if expected_err is not None:
     assert stderr == subprocess.PIPE or stderr is None,\
         "Can't redirect stderr if using expected_err"
@@ -158,11 +158,13 @@ def run_command(cmd, expected_status=0, stderr=None,
   code = proc.returncode
   if expected_status is not None and code != expected_status:
     raise Exception(('run_command failed (%s)' % code, out + str(err or '')))
-  err_correct = expected_err is None or \
-      (expected_err in err if err_contains else expected_err == err)
-  if not err_correct:
-    raise Exception(('run_command unexpected stderr',
-                     "expected '%s', actual '%s'" % (expected_err, err)))
+  if expected_err is not None:
+    if err_ignore is not None:
+      err = "\n".join([line for line in err.split('\n') if err_ignore not in line])
+    err_correct = expected_err in err if err_contains else expected_err == err
+    if not err_correct:
+      raise Exception(('run_command unexpected stderr',
+                       "expected '%s', actual '%s'" % (expected_err, err)))
   return out
 
 
diff --git a/scripts/test/wasm2asm.py b/scripts/test/wasm2js.py
index 41fdaf9b7..9a72895c1 100755
--- a/scripts/test/wasm2asm.py
+++ b/scripts/test/wasm2js.py
@@ -18,7 +18,7 @@ import os
 
 from support import run_command
 from shared import (
-    WASM2ASM, MOZJS, NODEJS, fail_if_not_identical, options, tests,
+    WASM2JS, MOZJS, NODEJS, fail_if_not_identical, options, tests,
     fail_if_not_identical_to_file
 )
 
@@ -27,26 +27,31 @@ spec_dir = os.path.join(options.binaryen_test, 'spec')
 spec_tests = [os.path.join(spec_dir, t)
               for t in sorted(os.listdir(spec_dir))
               if '.fail' not in t]
-wasm2asm_dir = os.path.join(options.binaryen_test, 'wasm2asm')
-extra_wasm2asm_tests = [os.path.join(wasm2asm_dir, t) for t in
-                        sorted(os.listdir(wasm2asm_dir))]
-assert_tests = ['wasm2asm.wast.asserts']
+wasm2js_dir = os.path.join(options.binaryen_test, 'wasm2js')
+extra_wasm2js_tests = [os.path.join(wasm2js_dir, t) for t in
+                       sorted(os.listdir(wasm2js_dir))]
+assert_tests = ['wasm2js.wast.asserts']
+# These tests exercise functionality not supported by wasm2js
+wasm2js_blacklist = ['empty_imported_table.wast']
 
 
-def test_wasm2asm_output():
-  for wasm in tests + spec_tests + extra_wasm2asm_tests:
+def test_wasm2js_output():
+  for wasm in tests + spec_tests + extra_wasm2js_tests:
     if not wasm.endswith('.wast'):
       continue
+    basename = os.path.basename(wasm)
+    if basename in wasm2js_blacklist:
+      continue
 
-    asm = os.path.basename(wasm).replace('.wast', '.2asm.js')
-    expected_file = os.path.join(wasm2asm_dir, asm)
+    asm = basename.replace('.wast', '.2asm.js')
+    expected_file = os.path.join(wasm2js_dir, asm)
 
     if not os.path.exists(expected_file):
       continue
 
     print '..', wasm
 
-    cmd = WASM2ASM + [os.path.join(options.binaryen_test, wasm)]
+    cmd = WASM2JS + [os.path.join(options.binaryen_test, wasm)]
     out = run_command(cmd)
     fail_if_not_identical_to_file(out, expected_file)
 
@@ -54,32 +59,27 @@ def test_wasm2asm_output():
       print 'No JS interpreters. Skipping spec tests.'
       continue
 
-    open('a.2asm.js', 'w').write(out)
+    open('a.2asm.mjs', 'w').write(out)
 
     cmd += ['--allow-asserts']
     out = run_command(cmd)
 
-    open('a.2asm.asserts.js', 'w').write(out)
+    open('a.2asm.asserts.mjs', 'w').write(out)
 
-    # verify asm.js is valid js
+    # verify asm.js is valid js, note that we're using --experimental-modules
+    # to enable ESM syntax and we're also passing a custom loader to handle the
+    # `spectest` module in our tests.
     if NODEJS:
-      out = run_command([NODEJS, 'a.2asm.js'])
+      node = [NODEJS, '--experimental-modules', '--loader', './scripts/test/node-esm-loader.mjs']
+      cmd = node[:]
+      cmd.append('a.2asm.mjs')
+      out = run_command(cmd)
       fail_if_not_identical(out, '')
-      out = run_command([NODEJS, 'a.2asm.asserts.js'], expected_err='')
+      cmd = node[:]
+      cmd.append('a.2asm.asserts.mjs')
+      out = run_command(cmd, expected_err='', err_ignore='The ESM module loader is experimental')
       fail_if_not_identical(out, '')
 
-    if MOZJS:
-      # verify asm.js validates, if this is asm.js code (we emit
-      # almost-asm instead when we need to)
-      if 'use asm' in open('a.2asm.js').read():
-        # check only subset of err because mozjs emits timing info
-        out = run_command([MOZJS, '-w', 'a.2asm.js'],
-                          expected_err='Successfully compiled asm.js code',
-                          err_contains=True)
-        fail_if_not_identical(out, '')
-        out = run_command([MOZJS, 'a.2asm.asserts.js'], expected_err='')
-        fail_if_not_identical(out, '')
-
 
 def test_asserts_output():
   for wasm in assert_tests:
@@ -90,8 +90,8 @@ def test_asserts_output():
     asserts_expected_file = os.path.join(options.binaryen_test, asserts)
     traps_expected_file = os.path.join(options.binaryen_test, traps)
 
-    wasm = os.path.join(wasm2asm_dir, wasm)
-    cmd = WASM2ASM + [wasm, '--allow-asserts']
+    wasm = os.path.join(wasm2js_dir, wasm)
+    cmd = WASM2JS + [wasm, '--allow-asserts']
     out = run_command(cmd)
     fail_if_not_identical_to_file(out, asserts_expected_file)
 
@@ -100,11 +100,11 @@ def test_asserts_output():
     fail_if_not_identical_to_file(out, traps_expected_file)
 
 
-def test_wasm2asm():
-  print '\n[ checking wasm2asm testcases... ]\n'
-  test_wasm2asm_output()
+def test_wasm2js():
+  print '\n[ checking wasm2js testcases... ]\n'
+  test_wasm2js_output()
   test_asserts_output()
 
 
 if __name__ == "__main__":
-  test_wasm2asm()
+  test_wasm2js()
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 33281ff82..903a179c6 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -29,7 +29,7 @@
 #include "wasm-printing.h"
 #include "wasm-s-parser.h"
 #include "wasm-validator.h"
-#include "wasm2asm.h"
+#include "wasm2js.h"
 #include "cfg/Relooper.h"
 #include "ir/utils.h"
 #include "shell-interface.h"
@@ -2008,9 +2008,9 @@ void BinaryenModulePrintAsmjs(BinaryenModuleRef module) {
   }
 
   Module* wasm = (Module*)module;
-  Wasm2AsmBuilder::Flags builderFlags;
-  Wasm2AsmBuilder wasm2asm(builderFlags);
-  Ref asmjs = wasm2asm.processWasm(wasm);
+  Wasm2JSBuilder::Flags builderFlags;
+  Wasm2JSBuilder wasm2js(builderFlags);
+  Ref asmjs = wasm2js.processWasm(wasm);
   JSPrinter jser(true, true, asmjs);
   jser.printAst();
 
diff --git a/src/tools/wasm2asm.cpp b/src/tools/wasm2js.cpp
index fd65ca5e6..8a57a5a1a 100644
--- a/src/tools/wasm2asm.cpp
+++ b/src/tools/wasm2js.cpp
@@ -15,21 +15,21 @@
  */
 
 //
-// wasm2asm console tool
+// wasm2js console tool
 //
 
 #include "support/colors.h"
 #include "support/command-line.h"
 #include "support/file.h"
 #include "wasm-s-parser.h"
-#include "wasm2asm.h"
+#include "wasm2js.h"
 
 using namespace cashew;
 using namespace wasm;
 
 int main(int argc, const char *argv[]) {
-  Wasm2AsmBuilder::Flags builderFlags;
-  Options options("wasm2asm", "Transform .wast files to asm.js");
+  Wasm2JSBuilder::Flags builderFlags;
+  Options options("wasm2js", "Transform .wasm/.wast files to asm.js");
   options
       .add("--output", "-o", "Output file (stdout if not specified)",
            Options::Arguments::One,
@@ -55,28 +55,49 @@ int main(int argc, const char *argv[]) {
   options.parse(argc, argv);
   if (options.debug) builderFlags.debug = true;
 
-  auto input(
-      read_file<std::vector<char>>(options.extra["infile"], Flags::Text, options.debug ? Flags::Debug : Flags::Release));
-
   Element* root;
   Module wasm;
   Ref asmjs;
 
   try {
-    if (options.debug) std::cerr << "s-parsing..." << std::endl;
-    SExpressionParser parser(input.data());
-    root = parser.root;
+    // If the input filename ends in `.wasm`, then parse it in binary form,
+    // otherwise assume it's a `*.wast` file and go from there.
+    //
+    // Note that we're not using the built-in `ModuleReader` which will also do
+    // similar logic here because when testing JS files we use the
+    // `--allow-asserts` flag which means we need to parse the extra
+    // s-expressions that come at the end of the `*.wast` file after the module
+    // is defined.
+    auto &input = options.extra["infile"];
+    std::string suffix(".wasm");
+    if (input.size() >= suffix.size() &&
+        input.compare(input.size() - suffix.size(), suffix.size(), suffix) == 0) {
+      ModuleReader reader;
+      reader.setDebug(options.debug);
+      reader.read(input, wasm, "");
+
+      if (options.debug) std::cerr << "asming..." << std::endl;
+      Wasm2JSBuilder wasm2js(builderFlags);
+      asmjs = wasm2js.processWasm(&wasm);
+
+    } else {
+      auto input(
+          read_file<std::vector<char>>(options.extra["infile"], Flags::Text, options.debug ? Flags::Debug : Flags::Release));
+      if (options.debug) std::cerr << "s-parsing..." << std::endl;
+      SExpressionParser parser(input.data());
+      root = parser.root;
 
-    if (options.debug) std::cerr << "w-parsing..." << std::endl;
-    SExpressionWasmBuilder builder(wasm, *(*root)[0]);
+      if (options.debug) std::cerr << "w-parsing..." << std::endl;
+      SExpressionWasmBuilder builder(wasm, *(*root)[0]);
 
-    if (options.debug) std::cerr << "asming..." << std::endl;
-    Wasm2AsmBuilder wasm2asm(builderFlags);
-    asmjs = wasm2asm.processWasm(&wasm);
+      if (options.debug) std::cerr << "asming..." << std::endl;
+      Wasm2JSBuilder wasm2js(builderFlags);
+      asmjs = wasm2js.processWasm(&wasm);
 
-    if (options.extra["asserts"] == "1") {
-      if (options.debug) std::cerr << "asserting..." << std::endl;
-      flattenAppend(asmjs, wasm2asm.processAsserts(&wasm, *root, builder));
+      if (options.extra["asserts"] == "1") {
+        if (options.debug) std::cerr << "asserting..." << std::endl;
+        flattenAppend(asmjs, wasm2js.processAsserts(&wasm, *root, builder));
+      }
     }
   } catch (ParseException& p) {
     p.dump(std::cerr);
diff --git a/src/wasm2asm.h b/src/wasm2js.h
index e89352432..40f8e3057 100644
--- a/src/wasm2asm.h
+++ b/src/wasm2js.h
@@ -19,8 +19,8 @@
 // infrastructure.
 //
 
-#ifndef wasm_wasm2asm_h
-#define wasm_wasm2asm_h
+#ifndef wasm_wasm2js_h
+#define wasm_wasm2js_h
 
 #include <cmath>
 #include <numeric>
@@ -45,8 +45,8 @@ using namespace cashew;
 IString ASM_FUNC("asmFunc"),
         ABORT_FUNC("abort"),
         FUNCTION_TABLE("FUNCTION_TABLE"),
-        NO_RESULT("wasm2asm$noresult"), // no result at all
-        EXPRESSION_RESULT("wasm2asm$expresult"); // result in an expression, no temp var
+        NO_RESULT("wasm2js$noresult"), // no result at all
+        EXPRESSION_RESULT("wasm2js$expresult"); // result in an expression, no temp var
 
 // Appends extra to block, flattening out if extra is a block as well
 void flattenAppend(Ref ast, Ref extra) {
@@ -73,8 +73,9 @@ enum class NameScope {
   Max,
 };
 
-static uint64_t constOffset(Table::Segment &segment) {
-  auto* c = segment.offset->dynCast<Const>();
+template<typename T>
+static uint64_t constOffset(const T& segment) {
+  auto* c = segment.offset->template dynCast<Const>();
   if (!c) {
     Fatal() << "non-constant offsets aren't supported yet\n";
     abort();
@@ -83,7 +84,7 @@ static uint64_t constOffset(Table::Segment &segment) {
 }
 
 //
-// Wasm2AsmBuilder - converts a WebAssembly module into asm.js
+// Wasm2JSBuilder - converts a WebAssembly module into asm.js
 //
 // In general, asm.js => wasm is very straightforward, as can
 // be seen in asm2wasm.h. Just a single pass, plus a little
@@ -111,7 +112,7 @@ static uint64_t constOffset(Table::Segment &segment) {
 // can easily show bad behavior here, with many unnecessary
 // temp vars. We could rely on optimization passes like
 // Emscripten's eliminate/registerize pair, but we want
-// wasm2asm to be fairly fast to run, as it might run on
+// wasm2js to be fairly fast to run, as it might run on
 // the client.
 //
 // The approach taken here therefore performs 2 passes on
@@ -129,7 +130,7 @@ static uint64_t constOffset(Table::Segment &segment) {
 // optimizing away unnecessary forwarding.
 
 
-class Wasm2AsmBuilder {
+class Wasm2JSBuilder {
   MixedArena allocator;
 
 public:
@@ -139,7 +140,7 @@ public:
     bool allowAsserts = false;
   };
 
-  Wasm2AsmBuilder(Flags f) : flags(f) {}
+  Wasm2JSBuilder(Flags f) : flags(f) {}
 
   Ref processWasm(Module* wasm, Name funcName = ASM_FUNC);
   Ref processFunction(Module* wasm, Function* func);
@@ -166,7 +167,7 @@ public:
       frees[type].pop_back();
     } else {
       size_t index = temps[type]++;
-      ret = IString((std::string("wasm2asm_") + printType(type) + "$" +
+      ret = IString((std::string("wasm2js_") + printType(type) + "$" +
                      std::to_string(index)).c_str(), false);
     }
     if (func->localIndices.find(ret) == func->localIndices.end()) {
@@ -268,6 +269,8 @@ private:
 
   bool almostASM = false;
 
+  void addEsmImports(Ref ast, Module* wasm);
+  void addEsmExportsAndInstantiate(Ref ast, Module* wasm, Name funcName);
   void addBasics(Ref ast);
   void addImport(Ref ast, Import* import);
   void addTables(Ref ast, Module* wasm);
@@ -294,12 +297,12 @@ private:
                          Element& e,
                          Name testFuncName,
                          Name asmModule);
-  Wasm2AsmBuilder() = delete;
-  Wasm2AsmBuilder(const Wasm2AsmBuilder &) = delete;
-  Wasm2AsmBuilder &operator=(const Wasm2AsmBuilder&) = delete;
+  Wasm2JSBuilder() = delete;
+  Wasm2JSBuilder(const Wasm2JSBuilder &) = delete;
+  Wasm2JSBuilder &operator=(const Wasm2JSBuilder&) = delete;
 };
 
-Ref Wasm2AsmBuilder::processWasm(Module* wasm, Name funcName) {
+Ref Wasm2JSBuilder::processWasm(Module* wasm, Name funcName) {
   PassRunner runner(wasm);
   runner.add<AutoDrop>();
   // First up remove as many non-JS operations we can, including things like
@@ -328,8 +331,10 @@ Ref Wasm2AsmBuilder::processWasm(Module* wasm, Name funcName) {
 #endif
 
   Ref ret = ValueBuilder::makeToplevel();
+  addEsmImports(ret, wasm);
   Ref asmFunc = ValueBuilder::makeFunction(funcName);
   ret[1]->push_back(asmFunc);
+  addEsmExportsAndInstantiate(ret, wasm, funcName);
   ValueBuilder::appendArgumentToFunction(asmFunc, GLOBAL);
   ValueBuilder::appendArgumentToFunction(asmFunc, ENV);
   ValueBuilder::appendArgumentToFunction(asmFunc, BUFFER);
@@ -397,7 +402,207 @@ Ref Wasm2AsmBuilder::processWasm(Module* wasm, Name funcName) {
   return ret;
 }
 
-void Wasm2AsmBuilder::addBasics(Ref ast) {
+void Wasm2JSBuilder::addEsmImports(Ref ast, Module *wasm) {
+  std::unordered_map<Name, Name> nameMap;
+
+  for (auto& import : wasm->imports) {
+    // Only function imports are supported for now, but eventually imported
+    // memories can probably be supported at least.
+    switch (import->kind) {
+      case ExternalKind::Function: break;
+      default:
+        Fatal() << "non-function imports aren't supported yet\n";
+        abort();
+    }
+
+    // Right now codegen requires a flat namespace going into the module,
+    // meaning we don't importing the same name from multiple namespaces yet.
+    if (nameMap.count(import->base) && nameMap[import->base] != import->module) {
+        Fatal() << "the name " << import->base << " cannot be imported from "
+            << "two different modules yet\n";
+        abort();
+    }
+
+    nameMap[import->base] = import->module;
+
+    std::ostringstream out;
+    out << "import { "
+      << import->base.str
+      << " } from '"
+      << import->module.str
+      << "'";
+    std::string os = out.str();
+    IString name(os.c_str(), false);
+    flattenAppend(ast, ValueBuilder::makeName(name));
+  }
+}
+
+static std::string base64Encode(std::vector<char> &data) {
+  std::string ret;
+  size_t i = 0;
+
+  const char* alphabet =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz"
+    "0123456789+/";
+
+  while (i + 3 <= data.size()) {
+    int bits =
+      (((int) data[i + 0]) << 16) |
+      (((int) data[i + 1]) << 8) |
+      (((int) data[i + 2]) << 0);
+    ret += alphabet[(bits >> 18) & 0x3f];
+    ret += alphabet[(bits >> 12) & 0x3f];
+    ret += alphabet[(bits >> 6) & 0x3f];
+    ret += alphabet[(bits >> 0) & 0x3f];
+    i += 3;
+  }
+
+  if (i + 2 == data.size()) {
+    int bits =
+      (((int) data[i + 0]) << 8) |
+      (((int) data[i + 1]) << 0);
+    ret += alphabet[(bits >> 10) & 0x3f];
+    ret += alphabet[(bits >> 4) & 0x3f];
+    ret += alphabet[(bits << 2) & 0x3f];
+    ret += '=';
+  } else if (i + 1 == data.size()) {
+    int bits =(int) data[i + 0];
+    ret += alphabet[(bits >> 2) & 0x3f];
+    ret += alphabet[(bits << 4) & 0x3f];
+    ret += '=';
+    ret += '=';
+  } else {
+    assert(i == data.size());
+  }
+
+  return ret;
+}
+
+void Wasm2JSBuilder::addEsmExportsAndInstantiate(Ref ast, Module *wasm, Name funcName) {
+  // Create an initial `ArrayBuffer` and populate it with static data.
+  // Currently we use base64 encoding to encode static data and we decode it at
+  // instantiation time.
+  //
+  // Note that the translation here expects that the lower values of this memory
+  // can be used for conversions, so make sure there's at least one page.
+  {
+    auto pages = wasm->memory.initial == 0 ? 1 : wasm->memory.initial.addr;
+    std::ostringstream out;
+    out << "const mem" << funcName.str << " = new ArrayBuffer("
+      << pages * Memory::kPageSize
+      << ")";
+    std::string os = out.str();
+    IString name(os.c_str(), false);
+    flattenAppend(ast, ValueBuilder::makeName(name));
+  }
+
+  if (wasm->memory.segments.size() > 0) {
+    auto expr = R"(
+      function(mem) {
+        const _mem = new Uint8Array(mem);
+        return function(offset, s) {
+          if (typeof Buffer === 'undefined') {
+            const bytes = atob(s);
+            for (let i = 0; i < bytes.length; i++)
+              _mem[offset + i] = bytes.charCodeAt(i);
+          } else {
+            const bytes = Buffer.from(s, 'base64');
+            for (let i = 0; i < bytes.length; i++)
+              _mem[offset + i] = bytes[i];
+          }
+        }
+      }
+    )";
+
+    // const assign$name = ($expr)(mem$name);
+    std::ostringstream out;
+    out << "const assign" << funcName.str
+      << " = (" << expr << ")(mem" << funcName.str << ")";
+    std::string os = out.str();
+    IString name(os.c_str(), false);
+    flattenAppend(ast, ValueBuilder::makeName(name));
+  }
+  for (auto& seg : wasm->memory.segments) {
+    std::ostringstream out;
+    out << "assign" << funcName.str << "("
+      << constOffset(seg)
+      << ", \""
+      << base64Encode(seg.data)
+      << "\")";
+    std::string os = out.str();
+    IString name(os.c_str(), false);
+    flattenAppend(ast, ValueBuilder::makeName(name));
+  }
+
+  // Actually invoke the `asmFunc` generated function, passing in all global
+  // values followed by all imports (imported via addEsmImports above)
+  std::ostringstream construct;
+  construct << "const ret" << funcName.str << " = " << funcName.str << "({"
+    << "Math,"
+    << "Int8Array,"
+    << "Uint8Array,"
+    << "Int16Array,"
+    << "Uint16Array,"
+    << "Int32Array,"
+    << "Uint32Array,"
+    << "Float32Array,"
+    << "Float64Array,"
+    << "NaN,"
+    << "Infinity"
+    << "}, {";
+
+  construct << "abort:function() { throw new Error('abort'); }";
+  for (auto& import : wasm->imports) {
+    switch (import->kind) {
+      case ExternalKind::Function: break;
+      default: continue;
+    }
+    construct << "," << import->base.str;
+  }
+  construct << "},mem" << funcName.str << ")";
+  std::string sconstruct = construct.str();
+  IString name(sconstruct.c_str(), false);
+  flattenAppend(ast, ValueBuilder::makeName(name));
+
+  if (flags.allowAsserts) {
+    return;
+  }
+
+  // And now that we have our returned instance, export all our functions
+  // that are hanging off it.
+  for (auto& exp : wasm->exports) {
+    switch (exp->kind) {
+      case ExternalKind::Function:
+      case ExternalKind::Memory:
+        break;
+
+      // Exported globals and function tables aren't supported yet
+      default:
+        continue;
+    }
+    std::ostringstream export_name;
+    for (auto *ptr = exp->name.str; *ptr; ptr++) {
+      if (*ptr == '-') {
+        export_name << '_';
+      } else {
+        export_name << *ptr;
+      }
+    }
+    std::ostringstream out;
+    out << "export const "
+      << fromName(exp->name, NameScope::Top).str
+      << " = ret"
+      << funcName.str
+      << "."
+      << fromName(exp->name, NameScope::Top).str;
+    std::string os = out.str();
+    IString name(os.c_str(), false);
+    flattenAppend(ast, ValueBuilder::makeName(name));
+  }
+}
+
+void Wasm2JSBuilder::addBasics(Ref ast) {
   // heaps, var HEAP8 = new global.Int8Array(buffer); etc
   auto addHeap = [&](IString name, IString view) {
     Ref theVar = ValueBuilder::makeVar();
@@ -473,7 +678,7 @@ void Wasm2AsmBuilder::addBasics(Ref ast) {
   );
 }
 
-void Wasm2AsmBuilder::addImport(Ref ast, Import* import) {
+void Wasm2JSBuilder::addImport(Ref ast, Import* import) {
   Ref theVar = ValueBuilder::makeVar();
   ast->push_back(theVar);
   Ref module = ValueBuilder::makeName(ENV); // TODO: handle nested module imports
@@ -486,7 +691,7 @@ void Wasm2AsmBuilder::addImport(Ref ast, Import* import) {
   );
 }
 
-void Wasm2AsmBuilder::addTables(Ref ast, Module* wasm) {
+void Wasm2JSBuilder::addTables(Ref ast, Module* wasm) {
   std::map<std::string, std::vector<IString>> tables; // asm.js tables, sig => contents of table
   for (Table::Segment& seg : wasm->table.segments) {
     for (size_t i = 0; i < seg.data.size(); i++) {
@@ -521,7 +726,7 @@ void Wasm2AsmBuilder::addTables(Ref ast, Module* wasm) {
   }
 }
 
-void Wasm2AsmBuilder::addExports(Ref ast, Module* wasm) {
+void Wasm2JSBuilder::addExports(Ref ast, Module* wasm) {
   Ref exports = ValueBuilder::makeObject();
   for (auto& export_ : wasm->exports) {
     if (export_->kind == ExternalKind::Function) {
@@ -576,7 +781,7 @@ void Wasm2AsmBuilder::addExports(Ref ast, Module* wasm) {
   ast->push_back(ValueBuilder::makeStatement(ValueBuilder::makeReturn(exports)));
 }
 
-void Wasm2AsmBuilder::addGlobal(Ref ast, Global* global) {
+void Wasm2JSBuilder::addGlobal(Ref ast, Global* global) {
   if (auto* const_ = global->init->dynCast<Const>()) {
     Ref theValue;
     switch (const_->type) {
@@ -620,7 +825,7 @@ static bool expressionEndsInReturn(Expression *e) {
   return expressionEndsInReturn((*stats)[stats->size()-1]);
 }
 
-Ref Wasm2AsmBuilder::processFunction(Module* m, Function* func) {
+Ref Wasm2JSBuilder::processFunction(Module* m, Function* func) {
   if (flags.debug) {
     static int fns = 0;
     std::cerr << "processFunction " << (fns++) << " " << func->name
@@ -704,11 +909,11 @@ Ref Wasm2AsmBuilder::processFunction(Module* m, Function* func) {
   return ret;
 }
 
-void Wasm2AsmBuilder::scanFunctionBody(Expression* curr) {
+void Wasm2JSBuilder::scanFunctionBody(Expression* curr) {
   struct ExpressionScanner : public PostWalker<ExpressionScanner> {
-    Wasm2AsmBuilder* parent;
+    Wasm2JSBuilder* parent;
 
-    ExpressionScanner(Wasm2AsmBuilder* parent) : parent(parent) {}
+    ExpressionScanner(Wasm2JSBuilder* parent) : parent(parent) {}
 
     // Visitors
 
@@ -792,26 +997,26 @@ void Wasm2AsmBuilder::scanFunctionBody(Expression* curr) {
   ExpressionScanner(this).walk(curr);
 }
 
-Ref Wasm2AsmBuilder::processFunctionBody(Module* m, Function* func, IString result) {
+Ref Wasm2JSBuilder::processFunctionBody(Module* m, Function* func, IString result) {
   struct ExpressionProcessor : public Visitor<ExpressionProcessor, Ref> {
-    Wasm2AsmBuilder* parent;
+    Wasm2JSBuilder* parent;
     IString result;
     Function* func;
     Module* module;
     MixedArena allocator;
-    ExpressionProcessor(Wasm2AsmBuilder* parent, Module* m, Function* func)
+    ExpressionProcessor(Wasm2JSBuilder* parent, Module* m, Function* func)
       : parent(parent), func(func), module(m) {}
 
     // A scoped temporary variable.
     struct ScopedTemp {
-      Wasm2AsmBuilder* parent;
+      Wasm2JSBuilder* parent;
       Type type;
       IString temp;
       bool needFree;
       // @param possible if provided, this is a variable we can use as our temp. it has already been
       //                 allocated in a higher scope, and we can just assign to it as our result is
       //                 going there anyhow.
-      ScopedTemp(Type type, Wasm2AsmBuilder* parent, Function* func,
+      ScopedTemp(Type type, Wasm2JSBuilder* parent, Function* func,
                  IString possible = NO_RESULT) : parent(parent), type(type) {
         assert(possible != EXPRESSION_RESULT);
         if (possible == NO_RESULT) {
@@ -1839,16 +2044,11 @@ Ref Wasm2AsmBuilder::processFunctionBody(Module* m, Function* func, IString resu
   return ExpressionProcessor(this, m, func).visit(func->body, result);
 }
 
-static void makeInstantiation(Ref ret, Name funcName, Name moduleName, bool first) {
-  Name buffer("__array_buffer");
+static void makeHelpers(Ref ret, Name funcName, Name moduleName, bool first) {
   if (first) {
     // TODO: nan and infinity shouldn't be needed once literal asm.js code isn't
     // generated
     flattenAppend(ret, ValueBuilder::makeName(R"(
-      var __array_buffer = new ArrayBuffer(65536)
-      var HEAP32 = new Int32Array(__array_buffer);
-      var HEAPF32 = new Float32Array(__array_buffer);
-      var HEAPF64 = new Float64Array(__array_buffer);
       var nan = NaN;
       var infinity = Infinity;
     )"));
@@ -1885,48 +2085,12 @@ static void makeInstantiation(Ref ret, Name funcName, Name moduleName, bool firs
 
          return (isNaN(a) && isNaN(b)) || (ai1 == bi1 && ai2 == bi2);
       }
+
+      function i64Equal(actual_lo, actual_hi, expected_lo, expected_hi) {
+         return actual_lo == (expected_lo | 0) && actual_hi == (expected_hi | 0);
+      }
     )"));
   }
-
-  Ref lib = ValueBuilder::makeObject();
-  auto insertItem = [&](IString item) {
-    ValueBuilder::appendToObject(lib, item, ValueBuilder::makeName(item));
-  };
-  insertItem(MATH);
-  insertItem(INT8ARRAY);
-  insertItem(INT16ARRAY);
-  insertItem(INT32ARRAY);
-  insertItem(UINT8ARRAY);
-  insertItem(UINT16ARRAY);
-  insertItem(UINT32ARRAY);
-  insertItem(FLOAT32ARRAY);
-  insertItem(FLOAT64ARRAY);
-  // TODO: these shouldn't be necessary once we don't generate literal asm.js
-  // code
-  insertItem("Infinity");
-  insertItem("NaN");
-  Ref env = ValueBuilder::makeObject();
-  Ref abortFunc = ValueBuilder::makeFunction("abort");
-  abortFunc[3]->push_back(ValueBuilder::makeCall("unreachable"));
-  ValueBuilder::appendToObject(env, "abort", abortFunc);
-
-  Ref printFunc = ValueBuilder::makeFunction("print");
-  abortFunc[3]->push_back(ValueBuilder::makeCall("console_log"));
-  ValueBuilder::appendToObject(env, "print", printFunc);
-  Ref call = ValueBuilder::makeCall(IString(funcName), lib, env,
-      ValueBuilder::makeName(buffer));
-  Ref module = ValueBuilder::makeVar();
-  ValueBuilder::appendToVar(module, moduleName, call);
-  flattenAppend(ret, module);
-
-  // 64-bit numbers get a different ABI w/ wasm2asm, and in general you can't
-  // actually export them from wasm at the boundary. We hack around this though
-  // to get the spec tests working.
-  flattenAppend(ret, ValueBuilder::makeName(R"(
-    function i64Equal(actual_lo, actual_hi, expected_lo, expected_hi) {
-       return actual_lo == (expected_lo | 0) && actual_hi == (expected_hi | 0);
-    }
-  )"));
 }
 
 static void prefixCalls(Ref asmjs, Name asmModule) {
@@ -1961,7 +2125,7 @@ static void prefixCalls(Ref asmjs, Name asmModule) {
   }
 }
 
-Ref Wasm2AsmBuilder::makeAssertReturnFunc(SExpressionWasmBuilder& sexpBuilder,
+Ref Wasm2JSBuilder::makeAssertReturnFunc(SExpressionWasmBuilder& sexpBuilder,
                                           Module* wasm,
                                           Builder& wasmBuilder,
                                           Element& e,
@@ -2026,7 +2190,7 @@ Ref Wasm2AsmBuilder::makeAssertReturnFunc(SExpressionWasmBuilder& sexpBuilder,
   return jsFunc;
 }
 
-Ref Wasm2AsmBuilder::makeAssertReturnNanFunc(SExpressionWasmBuilder& sexpBuilder,
+Ref Wasm2JSBuilder::makeAssertReturnNanFunc(SExpressionWasmBuilder& sexpBuilder,
                                              Module* wasm,
                                              Builder& wasmBuilder,
                                              Element& e,
@@ -2048,7 +2212,7 @@ Ref Wasm2AsmBuilder::makeAssertReturnNanFunc(SExpressionWasmBuilder& sexpBuilder
   return jsFunc;
 }
 
-Ref Wasm2AsmBuilder::makeAssertTrapFunc(SExpressionWasmBuilder& sexpBuilder,
+Ref Wasm2JSBuilder::makeAssertTrapFunc(SExpressionWasmBuilder& sexpBuilder,
                                         Module* wasm,
                                         Builder& wasmBuilder,
                                         Element& e,
@@ -2092,14 +2256,14 @@ Ref Wasm2AsmBuilder::makeAssertTrapFunc(SExpressionWasmBuilder& sexpBuilder,
   return outerFunc;
 }
 
-void Wasm2AsmBuilder::setNeedsAlmostASM(const char *reason) {
+void Wasm2JSBuilder::setNeedsAlmostASM(const char *reason) {
   if (!almostASM) {
     almostASM = true;
     std::cerr << "Switching to \"almost asm\" mode, reason: " << reason << std::endl;
   }
 }
 
-void Wasm2AsmBuilder::addMemoryGrowthFuncs(Ref ast) {
+void Wasm2JSBuilder::addMemoryGrowthFuncs(Ref ast) {
   Ref growMemoryFunc = ValueBuilder::makeFunction(WASM_GROW_MEMORY);
   ValueBuilder::appendArgumentToFunction(growMemoryFunc, IString("pagesToAdd"));
 
@@ -2250,7 +2414,7 @@ void Wasm2AsmBuilder::addMemoryGrowthFuncs(Ref ast) {
   ast->push_back(currentMemoryFunc);
 }
 
-bool Wasm2AsmBuilder::isAssertHandled(Element& e) {
+bool Wasm2JSBuilder::isAssertHandled(Element& e) {
   return e.isList() && e.size() >= 2 && e[0]->isStr()
       && (e[0]->str() == Name("assert_return") ||
           e[0]->str() == Name("assert_return_nan") ||
@@ -2259,26 +2423,28 @@ bool Wasm2AsmBuilder::isAssertHandled(Element& e) {
       && (*e[1])[0]->str() == Name("invoke");
 }
 
-Ref Wasm2AsmBuilder::processAsserts(Module* wasm,
+Ref Wasm2JSBuilder::processAsserts(Module* wasm,
                                     Element& root,
                                     SExpressionWasmBuilder& sexpBuilder) {
   Builder wasmBuilder(sexpBuilder.getAllocator());
   Ref ret = ValueBuilder::makeBlock();
-  Name asmModule = ASM_MODULE;
-  makeInstantiation(ret, ASM_FUNC, asmModule, true);
+  std::stringstream asmModuleS;
+  asmModuleS << "ret" << ASM_FUNC.c_str();
+  Name asmModule(asmModuleS.str().c_str());
+  makeHelpers(ret, ASM_FUNC, asmModule, true);
   for (size_t i = 1; i < root.size(); ++i) {
     Element& e = *root[i];
     if (e.isList() && e.size() >= 1 && e[0]->isStr() && e[0]->str() == Name("module")) {
       std::stringstream funcNameS;
       funcNameS << ASM_FUNC.c_str() << i;
       std::stringstream moduleNameS;
-      moduleNameS << ASM_MODULE.c_str() << i;
+      moduleNameS << "ret" << ASM_FUNC.c_str() << i;
       Name funcName(funcNameS.str().c_str());
       asmModule = Name(moduleNameS.str().c_str());
       Module wasm;
       SExpressionWasmBuilder builder(wasm, e);
       flattenAppend(ret, processWasm(&wasm, funcName));
-      makeInstantiation(ret, funcName, asmModule, false);
+      makeHelpers(ret, funcName, asmModule, false);
       continue;
     }
     if (!isAssertHandled(e)) {
@@ -2319,4 +2485,4 @@ Ref Wasm2AsmBuilder::processAsserts(Module* wasm,
 
 } // namespace wasm
 
-#endif // wasm_wasm2asm_h
+#endif // wasm_wasm2js_h
diff --git a/test/wasm2asm/address.2asm.js b/test/wasm2asm/address.2asm.js
deleted file mode 100644
index 115154057..000000000
--- a/test/wasm2asm/address.2asm.js
+++ /dev/null
@@ -1,53 +0,0 @@
-function asmFunc(global, env, buffer) {
- "use asm";
- var HEAP8 = new global.Int8Array(buffer);
- var HEAP16 = new global.Int16Array(buffer);
- var HEAP32 = new global.Int32Array(buffer);
- var HEAPU8 = new global.Uint8Array(buffer);
- var HEAPU16 = new global.Uint16Array(buffer);
- var HEAPU32 = new global.Uint32Array(buffer);
- var HEAPF32 = new global.Float32Array(buffer);
- var HEAPF64 = new global.Float64Array(buffer);
- var Math_imul = global.Math.imul;
- var Math_fround = global.Math.fround;
- var Math_abs = global.Math.abs;
- var Math_clz32 = global.Math.clz32;
- var Math_min = global.Math.min;
- var Math_max = global.Math.max;
- var Math_floor = global.Math.floor;
- var Math_ceil = global.Math.ceil;
- var Math_sqrt = global.Math.sqrt;
- var abort = env.abort;
- var nan = global.NaN;
- var infinity = global.Infinity;
- var print = env.print;
- var i64toi32_i32$HIGH_BITS = 0;
- function $0(i) {
-  i = i | 0;
-  var wasm2asm_i32$0 = 0;
-  print(HEAPU8[i >> 0] | 0 | 0);
-  print(HEAPU8[(i + 1 | 0) >> 0] | 0 | 0);
-  print(HEAPU8[(i + 2 | 0) >> 0] | 0 | 0);
-  print(HEAPU8[(i + 25 | 0) >> 0] | 0 | 0);
-  print(HEAPU16[i >> 1] | 0 | 0);
-  print((wasm2asm_i32$0 = i, HEAPU8[wasm2asm_i32$0 >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 1 | 0) >> 0] | 0 | 0) << 8) | 0);
-  print((wasm2asm_i32$0 = i, HEAPU8[(wasm2asm_i32$0 + 1 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 2 | 0) >> 0] | 0 | 0) << 8) | 0);
-  print(HEAPU16[(i + 2 | 0) >> 1] | 0 | 0);
-  print((wasm2asm_i32$0 = i, HEAPU8[(wasm2asm_i32$0 + 25 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 26 | 0) >> 0] | 0 | 0) << 8) | 0);
-  print(HEAPU32[i >> 2] | 0 | 0);
-  print((wasm2asm_i32$0 = i, HEAPU8[(wasm2asm_i32$0 + 1 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 2 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 3 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 4 | 0) >> 0] | 0 | 0) << 24) | 0);
-  print((wasm2asm_i32$0 = i, HEAPU8[(wasm2asm_i32$0 + 2 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 3 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 4 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 5 | 0) >> 0] | 0 | 0) << 24) | 0);
-  print((wasm2asm_i32$0 = i, HEAPU8[(wasm2asm_i32$0 + 25 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 26 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 27 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 28 | 0) >> 0] | 0 | 0) << 24) | 0);
- }
- 
- function $1(i) {
-  i = i | 0;
-  HEAPU32[(i + 4294967295 | 0) >> 2] | 0;
- }
- 
- return {
-  good: $0, 
-  bad: $1
- };
-}
-
diff --git a/test/wasm2asm/unaligned.2asm.js b/test/wasm2asm/unaligned.2asm.js
deleted file mode 100644
index f5993ce36..000000000
--- a/test/wasm2asm/unaligned.2asm.js
+++ /dev/null
@@ -1,111 +0,0 @@
-function asmFunc(global, env, buffer) {
- "use asm";
- var HEAP8 = new global.Int8Array(buffer);
- var HEAP16 = new global.Int16Array(buffer);
- var HEAP32 = new global.Int32Array(buffer);
- var HEAPU8 = new global.Uint8Array(buffer);
- var HEAPU16 = new global.Uint16Array(buffer);
- var HEAPU32 = new global.Uint32Array(buffer);
- var HEAPF32 = new global.Float32Array(buffer);
- var HEAPF64 = new global.Float64Array(buffer);
- var Math_imul = global.Math.imul;
- var Math_fround = global.Math.fround;
- var Math_abs = global.Math.abs;
- var Math_clz32 = global.Math.clz32;
- var Math_min = global.Math.min;
- var Math_max = global.Math.max;
- var Math_floor = global.Math.floor;
- var Math_ceil = global.Math.ceil;
- var Math_sqrt = global.Math.sqrt;
- var abort = env.abort;
- var nan = global.NaN;
- var infinity = global.Infinity;
- var i64toi32_i32$HIGH_BITS = 0;
- function $0() {
-  var wasm2asm_i32$0 = 0;
-  return (wasm2asm_i32$0 = 0, HEAPU8[wasm2asm_i32$0 >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 1 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 2 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 3 | 0) >> 0] | 0 | 0) << 24) | 0;
- }
- 
- function $1() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2asm_i32$0 = 0;
-  i64toi32_i32$2 = 0;
-  i64toi32_i32$0 = (wasm2asm_i32$0 = i64toi32_i32$2, HEAPU8[wasm2asm_i32$0 >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 1 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 2 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 3 | 0) >> 0] | 0 | 0) << 24);
-  i64toi32_i32$1 = (wasm2asm_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2asm_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
-  i64toi32_i32$1 = i64toi32_i32$1;
-  i64toi32_i32$0 = i64toi32_i32$0;
-  i64toi32_i32$HIGH_BITS = i64toi32_i32$1;
-  return i64toi32_i32$0 | 0;
- }
- 
- function $2() {
-  var wasm2asm_i32$0 = 0;
-  return Math_fround((HEAP32[0] = (wasm2asm_i32$0 = 0, HEAPU8[wasm2asm_i32$0 >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 1 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 2 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 3 | 0) >> 0] | 0 | 0) << 24), HEAPF32[0]));
- }
- 
- function $3() {
-  var i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0;
-  i64toi32_i32$2 = 0;
-  i64toi32_i32$1 = (wasm2asm_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2asm_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
-  i64toi32_i32$1 = i64toi32_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = (wasm2asm_i32$2 = i64toi32_i32$2, HEAPU8[wasm2asm_i32$2 >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$2 + 1 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$2 + 2 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$2 + 3 | 0) >> 0] | 0 | 0) << 24);
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$1;
-  HEAP32[(wasm2asm_i32$0 + 4 | 0) >> 2] = wasm2asm_i32$1;
-  return +(+HEAPF64[0 >> 3]);
- }
- 
- function $4() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = 0;
-  (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[wasm2asm_i32$2 >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 1 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 2 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 3 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
- }
- 
- function $5() {
-  var i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
-  i64toi32_i32$1 = 0;
-  wasm2asm_i32$0 = i64toi32_i32$1;
-  wasm2asm_i32$1 = 0;
-  (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[wasm2asm_i32$2 >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 1 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 2 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 3 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
-  wasm2asm_i32$0 = i64toi32_i32$1;
-  wasm2asm_i32$1 = 0;
-  (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
- }
- 
- function $6() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = (HEAPF32[0] = Math_fround(0.0), HEAP32[0] | 0);
-  (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[wasm2asm_i32$2 >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 1 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 2 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 3 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
- }
- 
- function $7() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 0.0;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
-  i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
-  i64toi32_i32$1 = 0;
-  i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = i64toi32_i32$1;
-  wasm2asm_i32$1 = HEAP32[0 >> 2] | 0;
-  (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[wasm2asm_i32$2 >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 1 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 2 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 3 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
-  wasm2asm_i32$0 = i64toi32_i32$1;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
- }
- 
- return {
-  i32_load: $0, 
-  i64_load: $1, 
-  f32_load: $2, 
-  f64_load: $3, 
-  i32_store: $4, 
-  i64_store: $5, 
-  f32_store: $6, 
-  f64_store: $7
- };
-}
-
diff --git a/test/wasm2js.asserts.js b/test/wasm2js.asserts.js
new file mode 100644
index 000000000..b097a5aaa
--- /dev/null
+++ b/test/wasm2js.asserts.js
@@ -0,0 +1,99 @@
+function asmFunc(global, env, buffer) {
+ "use asm";
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+ var Math_imul = global.Math.imul;
+ var Math_fround = global.Math.fround;
+ var Math_abs = global.Math.abs;
+ var Math_clz32 = global.Math.clz32;
+ var Math_min = global.Math.min;
+ var Math_max = global.Math.max;
+ var Math_floor = global.Math.floor;
+ var Math_ceil = global.Math.ceil;
+ var Math_sqrt = global.Math.sqrt;
+ var abort = env.abort;
+ var nan = global.NaN;
+ var infinity = global.Infinity;
+ var i64toi32_i32$HIGH_BITS = 0;
+ function $0() {
+  
+ }
+ 
+ function $1(x, y) {
+  x = x | 0;
+  y = y | 0;
+  return x + y | 0 | 0;
+ }
+ 
+ function $2(x, y) {
+  x = x | 0;
+  y = y | 0;
+  return (x | 0) / (y | 0) | 0 | 0;
+ }
+ 
+ function __wasm_fetch_high_bits() {
+  return i64toi32_i32$HIGH_BITS | 0;
+ }
+ 
+ return {
+  empty: $0, 
+  add: $1, 
+  div_s: $2, 
+  __wasm_fetch_high_bits: __wasm_fetch_high_bits
+ };
+}
+
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+
+      var nan = NaN;
+      var infinity = Infinity;
+    ;
+
+      function f32Equal(a, b) {
+         var i = new Int32Array(1);
+         var f = new Float32Array(i.buffer);
+         f[0] = a;
+         var ai = f[0];
+         f[0] = b;
+         var bi = f[0];
+
+         return (isNaN(a) && isNaN(b)) || a == b;
+      }
+
+      function f64Equal(a, b) {
+         var i = new Int32Array(2);
+         var f = new Float64Array(i.buffer);
+         f[0] = a;
+         var ai1 = i[0];
+         var ai2 = i[1];
+         f[0] = b;
+         var bi1 = i[0];
+         var bi2 = i[1];
+
+         return (isNaN(a) && isNaN(b)) || (ai1 == bi1 && ai2 == bi2);
+      }
+
+      function i64Equal(actual_lo, actual_hi, expected_lo, expected_hi) {
+         return actual_lo == (expected_lo | 0) && actual_hi == (expected_hi | 0);
+      }
+    ;
+function check1() {
+ var wasm2js_i32$0 = 0;
+ retasmFunc.empty();
+ wasm2js_i32$0 = 1;
+ return wasm2js_i32$0 | 0;
+}
+
+if (!check1()) fail1();
+function check2() {
+ return (retasmFunc.add(1 | 0, 1 | 0) | 0 | 0) == (2 | 0) | 0;
+}
+
+if (!check2()) fail2();
diff --git a/test/wasm2js.traps.js b/test/wasm2js.traps.js
new file mode 100644
index 000000000..290076432
--- /dev/null
+++ b/test/wasm2js.traps.js
@@ -0,0 +1,127 @@
+function asmFunc(global, env, buffer) {
+ "use asm";
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+ var Math_imul = global.Math.imul;
+ var Math_fround = global.Math.fround;
+ var Math_abs = global.Math.abs;
+ var Math_clz32 = global.Math.clz32;
+ var Math_min = global.Math.min;
+ var Math_max = global.Math.max;
+ var Math_floor = global.Math.floor;
+ var Math_ceil = global.Math.ceil;
+ var Math_sqrt = global.Math.sqrt;
+ var abort = env.abort;
+ var nan = global.NaN;
+ var infinity = global.Infinity;
+ var i64toi32_i32$HIGH_BITS = 0;
+ function $0() {
+  
+ }
+ 
+ function $1(x, y) {
+  x = x | 0;
+  y = y | 0;
+  return x + y | 0 | 0;
+ }
+ 
+ function $2(x, y) {
+  x = x | 0;
+  y = y | 0;
+  return (x | 0) / (y | 0) | 0 | 0;
+ }
+ 
+ function __wasm_fetch_high_bits() {
+  return i64toi32_i32$HIGH_BITS | 0;
+ }
+ 
+ return {
+  empty: $0, 
+  add: $1, 
+  div_s: $2, 
+  __wasm_fetch_high_bits: __wasm_fetch_high_bits
+ };
+}
+
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+
+      var nan = NaN;
+      var infinity = Infinity;
+    ;
+
+      function f32Equal(a, b) {
+         var i = new Int32Array(1);
+         var f = new Float32Array(i.buffer);
+         f[0] = a;
+         var ai = f[0];
+         f[0] = b;
+         var bi = f[0];
+
+         return (isNaN(a) && isNaN(b)) || a == b;
+      }
+
+      function f64Equal(a, b) {
+         var i = new Int32Array(2);
+         var f = new Float64Array(i.buffer);
+         f[0] = a;
+         var ai1 = i[0];
+         var ai2 = i[1];
+         f[0] = b;
+         var bi1 = i[0];
+         var bi2 = i[1];
+
+         return (isNaN(a) && isNaN(b)) || (ai1 == bi1 && ai2 == bi2);
+      }
+
+      function i64Equal(actual_lo, actual_hi, expected_lo, expected_hi) {
+         return actual_lo == (expected_lo | 0) && actual_hi == (expected_hi | 0);
+      }
+    ;
+function check1() {
+ var wasm2js_i32$0 = 0;
+ retasmFunc.empty();
+ wasm2js_i32$0 = 1;
+ return wasm2js_i32$0 | 0;
+}
+
+if (!check1()) fail1();
+function check2() {
+ return (retasmFunc.add(1 | 0, 1 | 0) | 0 | 0) == (2 | 0) | 0;
+}
+
+if (!check2()) fail2();
+function check3() {
+ function f() {
+  retasmFunc.div_s(0 | 0, 0 | 0);
+ }
+ 
+ try {
+  f();
+ } catch (e) {
+  return e.message.includes("integer divide by zero");
+ };
+ return 0;
+}
+
+if (!check3()) fail3();
+function check4() {
+ function f() {
+  retasmFunc.div_s(2147483648 | 0, 4294967295 | 0);
+ }
+ 
+ try {
+  f();
+ } catch (e) {
+  return e.message.includes("integer overflow");
+ };
+ return 0;
+}
+
+if (!check4()) fail4();
diff --git a/test/wasm2js/address.2asm.js b/test/wasm2js/address.2asm.js
new file mode 100644
index 000000000..205be25d7
--- /dev/null
+++ b/test/wasm2js/address.2asm.js
@@ -0,0 +1,75 @@
+import { print } from 'spectest';
+function asmFunc(global, env, buffer) {
+ "use asm";
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+ var Math_imul = global.Math.imul;
+ var Math_fround = global.Math.fround;
+ var Math_abs = global.Math.abs;
+ var Math_clz32 = global.Math.clz32;
+ var Math_min = global.Math.min;
+ var Math_max = global.Math.max;
+ var Math_floor = global.Math.floor;
+ var Math_ceil = global.Math.ceil;
+ var Math_sqrt = global.Math.sqrt;
+ var abort = env.abort;
+ var nan = global.NaN;
+ var infinity = global.Infinity;
+ var print = env.print;
+ var i64toi32_i32$HIGH_BITS = 0;
+ function $0(i) {
+  i = i | 0;
+  var wasm2js_i32$0 = 0;
+  print(HEAPU8[i >> 0] | 0 | 0);
+  print(HEAPU8[(i + 1 | 0) >> 0] | 0 | 0);
+  print(HEAPU8[(i + 2 | 0) >> 0] | 0 | 0);
+  print(HEAPU8[(i + 25 | 0) >> 0] | 0 | 0);
+  print(HEAPU16[i >> 1] | 0 | 0);
+  print((wasm2js_i32$0 = i, HEAPU8[wasm2js_i32$0 >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 1 | 0) >> 0] | 0 | 0) << 8) | 0);
+  print((wasm2js_i32$0 = i, HEAPU8[(wasm2js_i32$0 + 1 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 2 | 0) >> 0] | 0 | 0) << 8) | 0);
+  print(HEAPU16[(i + 2 | 0) >> 1] | 0 | 0);
+  print((wasm2js_i32$0 = i, HEAPU8[(wasm2js_i32$0 + 25 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 26 | 0) >> 0] | 0 | 0) << 8) | 0);
+  print(HEAPU32[i >> 2] | 0 | 0);
+  print((wasm2js_i32$0 = i, HEAPU8[(wasm2js_i32$0 + 1 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 2 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 3 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 4 | 0) >> 0] | 0 | 0) << 24) | 0);
+  print((wasm2js_i32$0 = i, HEAPU8[(wasm2js_i32$0 + 2 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 3 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 4 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 5 | 0) >> 0] | 0 | 0) << 24) | 0);
+  print((wasm2js_i32$0 = i, HEAPU8[(wasm2js_i32$0 + 25 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 26 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 27 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 28 | 0) >> 0] | 0 | 0) << 24) | 0);
+ }
+ 
+ function $1(i) {
+  i = i | 0;
+  HEAPU32[(i + 4294967295 | 0) >> 2] | 0;
+ }
+ 
+ return {
+  good: $0, 
+  bad: $1
+ };
+}
+
+const memasmFunc = new ArrayBuffer(65536);
+const assignasmFunc = (
+      function(mem) {
+        const _mem = new Uint8Array(mem);
+        return function(offset, s) {
+          if (typeof Buffer === 'undefined') {
+            const bytes = atob(s);
+            for (let i = 0; i < bytes.length; i++)
+              _mem[offset + i] = bytes.charCodeAt(i);
+          } else {
+            const bytes = Buffer.from(s, 'base64');
+            for (let i = 0; i < bytes.length; i++)
+              _mem[offset + i] = bytes[i];
+          }
+        }
+      }
+    )(memasmFunc);
+assignasmFunc(0, "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo=");
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); },print},memasmFunc);
+export const good = retasmFunc.good;
+export const bad = retasmFunc.bad;
diff --git a/test/wasm2asm/block.2asm.js b/test/wasm2js/block.2asm.js
index 09f60c058..10706a646 100644
--- a/test/wasm2asm/block.2asm.js
+++ b/test/wasm2js/block.2asm.js
@@ -194,3 +194,19 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const empty = retasmFunc.empty;
+export const singular = retasmFunc.singular;
+export const multi = retasmFunc.multi;
+export const nested = retasmFunc.nested;
+export const deep = retasmFunc.deep;
+export const as_unary_operand = retasmFunc.as_unary_operand;
+export const as_binary_operand = retasmFunc.as_binary_operand;
+export const as_test_operand = retasmFunc.as_test_operand;
+export const as_compare_operand = retasmFunc.as_compare_operand;
+export const break_bare = retasmFunc.break_bare;
+export const break_value = retasmFunc.break_value;
+export const break_repeated = retasmFunc.break_repeated;
+export const break_inner = retasmFunc.break_inner;
+export const effects = retasmFunc.effects;
diff --git a/test/wasm2asm/br.2asm.js b/test/wasm2js/br.2asm.js
index 737877b79..a877618a1 100644
--- a/test/wasm2asm/br.2asm.js
+++ b/test/wasm2js/br.2asm.js
@@ -676,3 +676,62 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const type_i32 = retasmFunc.type_i32;
+export const type_i64 = retasmFunc.type_i64;
+export const type_f32 = retasmFunc.type_f32;
+export const type_f64 = retasmFunc.type_f64;
+export const type_i32_value = retasmFunc.type_i32_value;
+export const type_i64_value = retasmFunc.type_i64_value;
+export const type_f32_value = retasmFunc.type_f32_value;
+export const type_f64_value = retasmFunc.type_f64_value;
+export const as_block_first = retasmFunc.as_block_first;
+export const as_block_mid = retasmFunc.as_block_mid;
+export const as_block_last = retasmFunc.as_block_last;
+export const as_block_value = retasmFunc.as_block_value;
+export const as_loop_first = retasmFunc.as_loop_first;
+export const as_loop_mid = retasmFunc.as_loop_mid;
+export const as_loop_last = retasmFunc.as_loop_last;
+export const as_br_value = retasmFunc.as_br_value;
+export const as_br_if_cond = retasmFunc.as_br_if_cond;
+export const as_br_if_value = retasmFunc.as_br_if_value;
+export const as_br_if_value_cond = retasmFunc.as_br_if_value_cond;
+export const as_br_table_index = retasmFunc.as_br_table_index;
+export const as_br_table_value = retasmFunc.as_br_table_value;
+export const as_br_table_value_index = retasmFunc.as_br_table_value_index;
+export const as_return_value = retasmFunc.as_return_value;
+export const as_if_cond = retasmFunc.as_if_cond;
+export const as_if_then = retasmFunc.as_if_then;
+export const as_if_else = retasmFunc.as_if_else;
+export const as_select_first = retasmFunc.as_select_first;
+export const as_select_second = retasmFunc.as_select_second;
+export const as_select_cond = retasmFunc.as_select_cond;
+export const as_call_first = retasmFunc.as_call_first;
+export const as_call_mid = retasmFunc.as_call_mid;
+export const as_call_last = retasmFunc.as_call_last;
+export const as_call_indirect_func = retasmFunc.as_call_indirect_func;
+export const as_call_indirect_first = retasmFunc.as_call_indirect_first;
+export const as_call_indirect_mid = retasmFunc.as_call_indirect_mid;
+export const as_call_indirect_last = retasmFunc.as_call_indirect_last;
+export const as_set_local_value = retasmFunc.as_set_local_value;
+export const as_load_address = retasmFunc.as_load_address;
+export const as_loadN_address = retasmFunc.as_loadN_address;
+export const as_store_address = retasmFunc.as_store_address;
+export const as_store_value = retasmFunc.as_store_value;
+export const as_storeN_address = retasmFunc.as_storeN_address;
+export const as_storeN_value = retasmFunc.as_storeN_value;
+export const as_unary_operand = retasmFunc.as_unary_operand;
+export const as_binary_left = retasmFunc.as_binary_left;
+export const as_binary_right = retasmFunc.as_binary_right;
+export const as_test_operand = retasmFunc.as_test_operand;
+export const as_compare_left = retasmFunc.as_compare_left;
+export const as_compare_right = retasmFunc.as_compare_right;
+export const as_convert_operand = retasmFunc.as_convert_operand;
+export const as_grow_memory_size = retasmFunc.as_grow_memory_size;
+export const nested_block_value = retasmFunc.nested_block_value;
+export const nested_br_value = retasmFunc.nested_br_value;
+export const nested_br_if_value = retasmFunc.nested_br_if_value;
+export const nested_br_if_value_cond = retasmFunc.nested_br_if_value_cond;
+export const nested_br_table_value = retasmFunc.nested_br_table_value;
+export const nested_br_table_value_index = retasmFunc.nested_br_table_value_index;
diff --git a/test/wasm2asm/br_if.2asm.js b/test/wasm2js/br_if.2asm.js
index e84d77208..ff17cc8eb 100644
--- a/test/wasm2asm/br_if.2asm.js
+++ b/test/wasm2js/br_if.2asm.js
@@ -255,3 +255,22 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const as_block_first = retasmFunc.as_block_first;
+export const as_block_mid = retasmFunc.as_block_mid;
+export const as_block_last = retasmFunc.as_block_last;
+export const as_block_first_value = retasmFunc.as_block_first_value;
+export const as_block_mid_value = retasmFunc.as_block_mid_value;
+export const as_block_last_value = retasmFunc.as_block_last_value;
+export const as_loop_first = retasmFunc.as_loop_first;
+export const as_loop_mid = retasmFunc.as_loop_mid;
+export const as_loop_last = retasmFunc.as_loop_last;
+export const as_if_then = retasmFunc.as_if_then;
+export const as_if_else = retasmFunc.as_if_else;
+export const nested_block_value = retasmFunc.nested_block_value;
+export const nested_br_value = retasmFunc.nested_br_value;
+export const nested_br_if_value = retasmFunc.nested_br_if_value;
+export const nested_br_if_value_cond = retasmFunc.nested_br_if_value_cond;
+export const nested_br_table_value = retasmFunc.nested_br_table_value;
+export const nested_br_table_value_index = retasmFunc.nested_br_table_value_index;
diff --git a/test/wasm2asm/br_table.2asm.js b/test/wasm2js/br_table.2asm.js
index c16d2fe03..655e2c96f 100644
--- a/test/wasm2asm/br_table.2asm.js
+++ b/test/wasm2js/br_table.2asm.js
@@ -50318,3 +50318,69 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const type_i32 = retasmFunc.type_i32;
+export const type_i64 = retasmFunc.type_i64;
+export const type_f32 = retasmFunc.type_f32;
+export const type_f64 = retasmFunc.type_f64;
+export const type_i32_value = retasmFunc.type_i32_value;
+export const type_i64_value = retasmFunc.type_i64_value;
+export const type_f32_value = retasmFunc.type_f32_value;
+export const type_f64_value = retasmFunc.type_f64_value;
+export const empty = retasmFunc.empty;
+export const empty_value = retasmFunc.empty_value;
+export const singleton = retasmFunc.singleton;
+export const singleton_value = retasmFunc.singleton_value;
+export const multiple = retasmFunc.multiple;
+export const multiple_value = retasmFunc.multiple_value;
+export const large = retasmFunc.large;
+export const as_block_first = retasmFunc.as_block_first;
+export const as_block_mid = retasmFunc.as_block_mid;
+export const as_block_last = retasmFunc.as_block_last;
+export const as_block_value = retasmFunc.as_block_value;
+export const as_loop_first = retasmFunc.as_loop_first;
+export const as_loop_mid = retasmFunc.as_loop_mid;
+export const as_loop_last = retasmFunc.as_loop_last;
+export const as_br_value = retasmFunc.as_br_value;
+export const as_br_if_cond = retasmFunc.as_br_if_cond;
+export const as_br_if_value = retasmFunc.as_br_if_value;
+export const as_br_if_value_cond = retasmFunc.as_br_if_value_cond;
+export const as_br_table_index = retasmFunc.as_br_table_index;
+export const as_br_table_value = retasmFunc.as_br_table_value;
+export const as_br_table_value_index = retasmFunc.as_br_table_value_index;
+export const as_return_value = retasmFunc.as_return_value;
+export const as_if_cond = retasmFunc.as_if_cond;
+export const as_if_then = retasmFunc.as_if_then;
+export const as_if_else = retasmFunc.as_if_else;
+export const as_select_first = retasmFunc.as_select_first;
+export const as_select_second = retasmFunc.as_select_second;
+export const as_select_cond = retasmFunc.as_select_cond;
+export const as_call_first = retasmFunc.as_call_first;
+export const as_call_mid = retasmFunc.as_call_mid;
+export const as_call_last = retasmFunc.as_call_last;
+export const as_call_indirect_first = retasmFunc.as_call_indirect_first;
+export const as_call_indirect_mid = retasmFunc.as_call_indirect_mid;
+export const as_call_indirect_last = retasmFunc.as_call_indirect_last;
+export const as_call_indirect_func = retasmFunc.as_call_indirect_func;
+export const as_set_local_value = retasmFunc.as_set_local_value;
+export const as_load_address = retasmFunc.as_load_address;
+export const as_loadN_address = retasmFunc.as_loadN_address;
+export const as_store_address = retasmFunc.as_store_address;
+export const as_store_value = retasmFunc.as_store_value;
+export const as_storeN_address = retasmFunc.as_storeN_address;
+export const as_storeN_value = retasmFunc.as_storeN_value;
+export const as_unary_operand = retasmFunc.as_unary_operand;
+export const as_binary_left = retasmFunc.as_binary_left;
+export const as_binary_right = retasmFunc.as_binary_right;
+export const as_test_operand = retasmFunc.as_test_operand;
+export const as_compare_left = retasmFunc.as_compare_left;
+export const as_compare_right = retasmFunc.as_compare_right;
+export const as_convert_operand = retasmFunc.as_convert_operand;
+export const as_grow_memory_size = retasmFunc.as_grow_memory_size;
+export const nested_block_value = retasmFunc.nested_block_value;
+export const nested_br_value = retasmFunc.nested_br_value;
+export const nested_br_if_value = retasmFunc.nested_br_if_value;
+export const nested_br_if_value_cond = retasmFunc.nested_br_if_value_cond;
+export const nested_br_table_value = retasmFunc.nested_br_table_value;
+export const nested_br_table_value_index = retasmFunc.nested_br_table_value_index;
diff --git a/test/wasm2asm/br_table_temp.2asm.js b/test/wasm2js/br_table_temp.2asm.js
index 08739a13f..97f5950ba 100644
--- a/test/wasm2asm/br_table_temp.2asm.js
+++ b/test/wasm2js/br_table_temp.2asm.js
@@ -50314,3 +50314,69 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const type_i32 = retasmFunc.type_i32;
+export const type_i64 = retasmFunc.type_i64;
+export const type_f32 = retasmFunc.type_f32;
+export const type_f64 = retasmFunc.type_f64;
+export const type_i32_value = retasmFunc.type_i32_value;
+export const type_i64_value = retasmFunc.type_i64_value;
+export const type_f32_value = retasmFunc.type_f32_value;
+export const type_f64_value = retasmFunc.type_f64_value;
+export const empty = retasmFunc.empty;
+export const empty_value = retasmFunc.empty_value;
+export const singleton = retasmFunc.singleton;
+export const singleton_value = retasmFunc.singleton_value;
+export const multiple = retasmFunc.multiple;
+export const multiple_value = retasmFunc.multiple_value;
+export const large = retasmFunc.large;
+export const as_block_first = retasmFunc.as_block_first;
+export const as_block_mid = retasmFunc.as_block_mid;
+export const as_block_last = retasmFunc.as_block_last;
+export const as_block_value = retasmFunc.as_block_value;
+export const as_loop_first = retasmFunc.as_loop_first;
+export const as_loop_mid = retasmFunc.as_loop_mid;
+export const as_loop_last = retasmFunc.as_loop_last;
+export const as_br_value = retasmFunc.as_br_value;
+export const as_br_if_cond = retasmFunc.as_br_if_cond;
+export const as_br_if_value = retasmFunc.as_br_if_value;
+export const as_br_if_value_cond = retasmFunc.as_br_if_value_cond;
+export const as_br_table_index = retasmFunc.as_br_table_index;
+export const as_br_table_value = retasmFunc.as_br_table_value;
+export const as_br_table_value_index = retasmFunc.as_br_table_value_index;
+export const as_return_value = retasmFunc.as_return_value;
+export const as_if_cond = retasmFunc.as_if_cond;
+export const as_if_then = retasmFunc.as_if_then;
+export const as_if_else = retasmFunc.as_if_else;
+export const as_select_first = retasmFunc.as_select_first;
+export const as_select_second = retasmFunc.as_select_second;
+export const as_select_cond = retasmFunc.as_select_cond;
+export const as_call_first = retasmFunc.as_call_first;
+export const as_call_mid = retasmFunc.as_call_mid;
+export const as_call_last = retasmFunc.as_call_last;
+export const as_call_indirect_first = retasmFunc.as_call_indirect_first;
+export const as_call_indirect_mid = retasmFunc.as_call_indirect_mid;
+export const as_call_indirect_last = retasmFunc.as_call_indirect_last;
+export const as_call_indirect_func = retasmFunc.as_call_indirect_func;
+export const as_set_local_value = retasmFunc.as_set_local_value;
+export const as_load_address = retasmFunc.as_load_address;
+export const as_loadN_address = retasmFunc.as_loadN_address;
+export const as_store_address = retasmFunc.as_store_address;
+export const as_store_value = retasmFunc.as_store_value;
+export const as_storeN_address = retasmFunc.as_storeN_address;
+export const as_storeN_value = retasmFunc.as_storeN_value;
+export const as_unary_operand = retasmFunc.as_unary_operand;
+export const as_binary_left = retasmFunc.as_binary_left;
+export const as_binary_right = retasmFunc.as_binary_right;
+export const as_test_operand = retasmFunc.as_test_operand;
+export const as_compare_left = retasmFunc.as_compare_left;
+export const as_compare_right = retasmFunc.as_compare_right;
+export const as_convert_operand = retasmFunc.as_convert_operand;
+export const as_grow_memory_size = retasmFunc.as_grow_memory_size;
+export const nested_block_value = retasmFunc.nested_block_value;
+export const nested_br_value = retasmFunc.nested_br_value;
+export const nested_br_if_value = retasmFunc.nested_br_if_value;
+export const nested_br_if_value_cond = retasmFunc.nested_br_if_value_cond;
+export const nested_br_table_value = retasmFunc.nested_br_table_value;
+export const nested_br_table_value_index = retasmFunc.nested_br_table_value_index;
diff --git a/test/wasm2asm/br_table_temp.wast b/test/wasm2js/br_table_temp.wast
index abd66053a..abd66053a 100644
--- a/test/wasm2asm/br_table_temp.wast
+++ b/test/wasm2js/br_table_temp.wast
diff --git a/test/wasm2asm/break-drop.2asm.js b/test/wasm2js/break-drop.2asm.js
index 9c5fd8e9b..5917b678b 100644
--- a/test/wasm2asm/break-drop.2asm.js
+++ b/test/wasm2js/break-drop.2asm.js
@@ -40,3 +40,8 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const br = retasmFunc.br;
+export const br_if = retasmFunc.br_if;
+export const br_table = retasmFunc.br_table;
diff --git a/test/wasm2asm/call.2asm.js b/test/wasm2js/call.2asm.js
index fb99bf74e..04255b1fb 100644
--- a/test/wasm2asm/call.2asm.js
+++ b/test/wasm2js/call.2asm.js
@@ -472,3 +472,24 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const type_i32 = retasmFunc.type_i32;
+export const type_i64 = retasmFunc.type_i64;
+export const type_f32 = retasmFunc.type_f32;
+export const type_f64 = retasmFunc.type_f64;
+export const type_first_i32 = retasmFunc.type_first_i32;
+export const type_first_i64 = retasmFunc.type_first_i64;
+export const type_first_f32 = retasmFunc.type_first_f32;
+export const type_first_f64 = retasmFunc.type_first_f64;
+export const type_second_i32 = retasmFunc.type_second_i32;
+export const type_second_i64 = retasmFunc.type_second_i64;
+export const type_second_f32 = retasmFunc.type_second_f32;
+export const type_second_f64 = retasmFunc.type_second_f64;
+export const fac = retasmFunc.fac;
+export const fac_acc = retasmFunc.fac_acc;
+export const fib = retasmFunc.fib;
+export const even = retasmFunc.even;
+export const odd = retasmFunc.odd;
+export const runaway = retasmFunc.runaway;
+export const mutual_runaway = retasmFunc.mutual_runaway;
diff --git a/test/wasm2asm/call_indirect.2asm.js b/test/wasm2js/call_indirect.2asm.js
index 109b478ad..7a051de37 100644
--- a/test/wasm2asm/call_indirect.2asm.js
+++ b/test/wasm2js/call_indirect.2asm.js
@@ -119,17 +119,17 @@ function asmFunc(global, env, buffer) {
  }
  
  function $16() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = FUNCTION_TABLE_i[wasm2asm_i32$1 & 31]() | 0;
-  return wasm2asm_i32$0 | 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = FUNCTION_TABLE_i[wasm2js_i32$1 & 31]() | 0;
+  return wasm2js_i32$0 | 0;
  }
  
  function $17() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$1 = 1;
-  wasm2asm_i32$0 = FUNCTION_TABLE_i[wasm2asm_i32$1 & 31]() | 0;
-  i64toi32_i32$0 = wasm2asm_i32$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$1 = 1;
+  wasm2js_i32$0 = FUNCTION_TABLE_i[wasm2js_i32$1 & 31]() | 0;
+  i64toi32_i32$0 = wasm2js_i32$0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -138,27 +138,27 @@ function asmFunc(global, env, buffer) {
  }
  
  function $18() {
-  var wasm2asm_f32$0 = Math_fround(0), wasm2asm_i32$0 = 0;
-  wasm2asm_i32$0 = 2;
-  wasm2asm_f32$0 = Math_fround(FUNCTION_TABLE_f[wasm2asm_i32$0 & 31]());
-  return Math_fround(wasm2asm_f32$0);
+  var wasm2js_f32$0 = Math_fround(0), wasm2js_i32$0 = 0;
+  wasm2js_i32$0 = 2;
+  wasm2js_f32$0 = Math_fround(FUNCTION_TABLE_f[wasm2js_i32$0 & 31]());
+  return Math_fround(wasm2js_f32$0);
  }
  
  function $19() {
-  var wasm2asm_f64$0 = 0.0, wasm2asm_i32$0 = 0;
-  wasm2asm_i32$0 = 3;
-  wasm2asm_f64$0 = +FUNCTION_TABLE_d[wasm2asm_i32$0 & 31]();
-  return +wasm2asm_f64$0;
+  var wasm2js_f64$0 = 0.0, wasm2js_i32$0 = 0;
+  wasm2js_i32$0 = 3;
+  wasm2js_f64$0 = +FUNCTION_TABLE_d[wasm2js_i32$0 & 31]();
+  return +wasm2js_f64$0;
  }
  
  function $20() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   i64toi32_i32$0 = 0;
-  wasm2asm_i32$2 = 100;
-  wasm2asm_i32$3 = i64toi32_i32$0;
-  wasm2asm_i32$1 = 5;
-  wasm2asm_i32$0 = FUNCTION_TABLE_iii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0, wasm2asm_i32$3 | 0) | 0;
-  i64toi32_i32$0 = wasm2asm_i32$0;
+  wasm2js_i32$2 = 100;
+  wasm2js_i32$3 = i64toi32_i32$0;
+  wasm2js_i32$1 = 5;
+  wasm2js_i32$0 = FUNCTION_TABLE_iii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0, wasm2js_i32$3 | 0) | 0;
+  i64toi32_i32$0 = wasm2js_i32$0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -167,21 +167,21 @@ function asmFunc(global, env, buffer) {
  }
  
  function $21() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0;
-  wasm2asm_i32$2 = 32;
-  wasm2asm_i32$1 = 4;
-  wasm2asm_i32$0 = FUNCTION_TABLE_ii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0) | 0;
-  return wasm2asm_i32$0 | 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
+  wasm2js_i32$2 = 32;
+  wasm2js_i32$1 = 4;
+  wasm2js_i32$0 = FUNCTION_TABLE_ii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0) | 0;
+  return wasm2js_i32$0 | 0;
  }
  
  function $22() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   i64toi32_i32$0 = 0;
-  wasm2asm_i32$2 = 64;
-  wasm2asm_i32$3 = i64toi32_i32$0;
-  wasm2asm_i32$1 = 5;
-  wasm2asm_i32$0 = FUNCTION_TABLE_iii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0, wasm2asm_i32$3 | 0) | 0;
-  i64toi32_i32$0 = wasm2asm_i32$0;
+  wasm2js_i32$2 = 64;
+  wasm2js_i32$3 = i64toi32_i32$0;
+  wasm2js_i32$1 = 5;
+  wasm2js_i32$0 = FUNCTION_TABLE_iii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0, wasm2js_i32$3 | 0) | 0;
+  i64toi32_i32$0 = wasm2js_i32$0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -190,39 +190,39 @@ function asmFunc(global, env, buffer) {
  }
  
  function $23() {
-  var wasm2asm_f32$0 = Math_fround(0), wasm2asm_i32$0 = 0, wasm2asm_f32$1 = Math_fround(0);
-  wasm2asm_f32$1 = Math_fround(1.3200000524520874);
-  wasm2asm_i32$0 = 6;
-  wasm2asm_f32$0 = Math_fround(FUNCTION_TABLE_ff[wasm2asm_i32$0 & 31](Math_fround(wasm2asm_f32$1)));
-  return Math_fround(wasm2asm_f32$0);
+  var wasm2js_f32$0 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f32$1 = Math_fround(0);
+  wasm2js_f32$1 = Math_fround(1.3200000524520874);
+  wasm2js_i32$0 = 6;
+  wasm2js_f32$0 = Math_fround(FUNCTION_TABLE_ff[wasm2js_i32$0 & 31](Math_fround(wasm2js_f32$1)));
+  return Math_fround(wasm2js_f32$0);
  }
  
  function $24() {
-  var wasm2asm_f64$0 = 0.0, wasm2asm_i32$0 = 0, wasm2asm_f64$1 = 0.0;
-  wasm2asm_f64$1 = 1.64;
-  wasm2asm_i32$0 = 7;
-  wasm2asm_f64$0 = +FUNCTION_TABLE_dd[wasm2asm_i32$0 & 31](+wasm2asm_f64$1);
-  return +wasm2asm_f64$0;
+  var wasm2js_f64$0 = 0.0, wasm2js_i32$0 = 0, wasm2js_f64$1 = 0.0;
+  wasm2js_f64$1 = 1.64;
+  wasm2js_i32$0 = 7;
+  wasm2js_f64$0 = +FUNCTION_TABLE_dd[wasm2js_i32$0 & 31](+wasm2js_f64$1);
+  return +wasm2js_f64$0;
  }
  
  function $25() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_f32$0 = Math_fround(0), wasm2asm_i32$2 = 0;
-  wasm2asm_f32$0 = Math_fround(32.099998474121094);
-  wasm2asm_i32$2 = 32;
-  wasm2asm_i32$1 = 8;
-  wasm2asm_i32$0 = FUNCTION_TABLE_ifi[wasm2asm_i32$1 & 31](Math_fround(wasm2asm_f32$0), wasm2asm_i32$2 | 0) | 0;
-  return wasm2asm_i32$0 | 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$2 = 0;
+  wasm2js_f32$0 = Math_fround(32.099998474121094);
+  wasm2js_i32$2 = 32;
+  wasm2js_i32$1 = 8;
+  wasm2js_i32$0 = FUNCTION_TABLE_ifi[wasm2js_i32$1 & 31](Math_fround(wasm2js_f32$0), wasm2js_i32$2 | 0) | 0;
+  return wasm2js_i32$0 | 0;
  }
  
  function $26() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0, wasm2asm_i32$4 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0, wasm2js_i32$4 = 0;
   i64toi32_i32$0 = 0;
-  wasm2asm_i32$2 = 32;
-  wasm2asm_i32$3 = 64;
-  wasm2asm_i32$4 = i64toi32_i32$0;
-  wasm2asm_i32$1 = 9;
-  wasm2asm_i32$0 = FUNCTION_TABLE_iiii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0, wasm2asm_i32$3 | 0, wasm2asm_i32$4 | 0) | 0;
-  i64toi32_i32$0 = wasm2asm_i32$0;
+  wasm2js_i32$2 = 32;
+  wasm2js_i32$3 = 64;
+  wasm2js_i32$4 = i64toi32_i32$0;
+  wasm2js_i32$1 = 9;
+  wasm2js_i32$0 = FUNCTION_TABLE_iiii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0, wasm2js_i32$3 | 0, wasm2js_i32$4 | 0) | 0;
+  i64toi32_i32$0 = wasm2js_i32$0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -231,36 +231,36 @@ function asmFunc(global, env, buffer) {
  }
  
  function $27() {
-  var wasm2asm_f32$0 = Math_fround(0), wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_f32$1 = Math_fround(0);
-  wasm2asm_f64$0 = 64.0;
-  wasm2asm_f32$1 = Math_fround(32.0);
-  wasm2asm_i32$0 = 10;
-  wasm2asm_f32$0 = Math_fround(FUNCTION_TABLE_fdf[wasm2asm_i32$0 & 31](+wasm2asm_f64$0, Math_fround(wasm2asm_f32$1)));
-  return Math_fround(wasm2asm_f32$0);
+  var wasm2js_f32$0 = Math_fround(0), wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_f32$1 = Math_fround(0);
+  wasm2js_f64$0 = 64.0;
+  wasm2js_f32$1 = Math_fround(32.0);
+  wasm2js_i32$0 = 10;
+  wasm2js_f32$0 = Math_fround(FUNCTION_TABLE_fdf[wasm2js_i32$0 & 31](+wasm2js_f64$0, Math_fround(wasm2js_f32$1)));
+  return Math_fround(wasm2js_f32$0);
  }
  
  function $28() {
-  var wasm2asm_f64$0 = 0.0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_f64$1 = 0.0;
-  wasm2asm_i32$1 = 64;
-  wasm2asm_i32$2 = 0;
-  wasm2asm_f64$1 = 64.1;
-  wasm2asm_i32$0 = 11;
-  wasm2asm_f64$0 = +FUNCTION_TABLE_diid[wasm2asm_i32$0 & 31](wasm2asm_i32$1 | 0, wasm2asm_i32$2 | 0, +wasm2asm_f64$1);
-  return +wasm2asm_f64$0;
+  var wasm2js_f64$0 = 0.0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_f64$1 = 0.0;
+  wasm2js_i32$1 = 64;
+  wasm2js_i32$2 = 0;
+  wasm2js_f64$1 = 64.1;
+  wasm2js_i32$0 = 11;
+  wasm2js_f64$0 = +FUNCTION_TABLE_diid[wasm2js_i32$0 & 31](wasm2js_i32$1 | 0, wasm2js_i32$2 | 0, +wasm2js_f64$1);
+  return +wasm2js_f64$0;
  }
  
  function $29($0, $1, $1$hi) {
   $0 = $0 | 0;
   $1 = $1 | 0;
   $1$hi = $1$hi | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   i64toi32_i32$0 = $1$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$2 = $1;
-  wasm2asm_i32$3 = i64toi32_i32$0;
-  wasm2asm_i32$1 = $0;
-  wasm2asm_i32$0 = FUNCTION_TABLE_iii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0, wasm2asm_i32$3 | 0) | 0;
-  i64toi32_i32$0 = wasm2asm_i32$0;
+  wasm2js_i32$2 = $1;
+  wasm2js_i32$3 = i64toi32_i32$0;
+  wasm2js_i32$1 = $0;
+  wasm2js_i32$0 = FUNCTION_TABLE_iii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0, wasm2js_i32$3 | 0) | 0;
+  i64toi32_i32$0 = wasm2js_i32$0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -270,13 +270,13 @@ function asmFunc(global, env, buffer) {
  
  function $30($0) {
   $0 = $0 | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   i64toi32_i32$0 = 0;
-  wasm2asm_i32$2 = 9;
-  wasm2asm_i32$3 = i64toi32_i32$0;
-  wasm2asm_i32$1 = $0;
-  wasm2asm_i32$0 = FUNCTION_TABLE_iii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0, wasm2asm_i32$3 | 0) | 0;
-  i64toi32_i32$0 = wasm2asm_i32$0;
+  wasm2js_i32$2 = 9;
+  wasm2js_i32$3 = i64toi32_i32$0;
+  wasm2js_i32$1 = $0;
+  wasm2js_i32$0 = FUNCTION_TABLE_iii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0, wasm2js_i32$3 | 0) | 0;
+  i64toi32_i32$0 = wasm2js_i32$0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -287,7 +287,7 @@ function asmFunc(global, env, buffer) {
  function fac($0, $0$hi) {
   $0 = $0 | 0;
   $0$hi = $0$hi | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$5 = 0, $8 = 0, $8$hi = 0, i64toi32_i32$3 = 0, $6 = 0, $6$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$5 = 0, $8 = 0, $8$hi = 0, i64toi32_i32$3 = 0, $6 = 0, $6$hi = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   i64toi32_i32$0 = $0$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
   if (($0 | i64toi32_i32$0 | 0 | 0) == (0 | 0)) {
@@ -303,11 +303,11 @@ function asmFunc(global, env, buffer) {
    i64toi32_i32$5 = (i64toi32_i32$2 >>> 0 < i64toi32_i32$3 >>> 0) + 0 | 0;
    i64toi32_i32$5 = i64toi32_i32$0 - i64toi32_i32$5 | 0;
    i64toi32_i32$5 = i64toi32_i32$5;
-   wasm2asm_i32$2 = i64toi32_i32$2 - i64toi32_i32$3 | 0;
-   wasm2asm_i32$3 = i64toi32_i32$5;
-   wasm2asm_i32$1 = 12;
-   wasm2asm_i32$0 = FUNCTION_TABLE_iii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0, wasm2asm_i32$3 | 0) | 0;
-   i64toi32_i32$5 = wasm2asm_i32$0;
+   wasm2js_i32$2 = i64toi32_i32$2 - i64toi32_i32$3 | 0;
+   wasm2js_i32$3 = i64toi32_i32$5;
+   wasm2js_i32$1 = 12;
+   wasm2js_i32$0 = FUNCTION_TABLE_iii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0, wasm2js_i32$3 | 0) | 0;
+   i64toi32_i32$5 = wasm2js_i32$0;
    i64toi32_i32$2 = i64toi32_i32$HIGH_BITS;
    $6 = i64toi32_i32$5;
    $6$hi = i64toi32_i32$2;
@@ -329,7 +329,7 @@ function asmFunc(global, env, buffer) {
  function fib($0, $0$hi) {
   $0 = $0 | 0;
   $0$hi = $0$hi | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, i64toi32_i32$5 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$6 = 0, $10 = 0, $10$hi = 0, $5 = 0, $5$hi = 0, $8 = 0, $8$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, i64toi32_i32$5 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$6 = 0, $10 = 0, $10$hi = 0, $5 = 0, $5$hi = 0, $8 = 0, $8$hi = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   i64toi32_i32$0 = $0$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$2 = $0;
@@ -350,11 +350,11 @@ function asmFunc(global, env, buffer) {
    i64toi32_i32$5 = i64toi32_i32$6 + i64toi32_i32$0 | 0;
    i64toi32_i32$5 = i64toi32_i32$2 - i64toi32_i32$5 | 0;
    i64toi32_i32$5 = i64toi32_i32$5;
-   wasm2asm_i32$2 = i64toi32_i32$4;
-   wasm2asm_i32$3 = i64toi32_i32$5;
-   wasm2asm_i32$1 = 13;
-   wasm2asm_i32$0 = FUNCTION_TABLE_iii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0, wasm2asm_i32$3 | 0) | 0;
-   i64toi32_i32$5 = wasm2asm_i32$0;
+   wasm2js_i32$2 = i64toi32_i32$4;
+   wasm2js_i32$3 = i64toi32_i32$5;
+   wasm2js_i32$1 = 13;
+   wasm2js_i32$0 = FUNCTION_TABLE_iii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0, wasm2js_i32$3 | 0) | 0;
+   i64toi32_i32$5 = wasm2js_i32$0;
    i64toi32_i32$3 = i64toi32_i32$HIGH_BITS;
    $5 = i64toi32_i32$5;
    $5$hi = i64toi32_i32$3;
@@ -368,11 +368,11 @@ function asmFunc(global, env, buffer) {
    i64toi32_i32$4 = i64toi32_i32$6 + i64toi32_i32$5 | 0;
    i64toi32_i32$4 = i64toi32_i32$3 - i64toi32_i32$4 | 0;
    i64toi32_i32$4 = i64toi32_i32$4;
-   wasm2asm_i32$3 = i64toi32_i32$0;
-   wasm2asm_i32$2 = i64toi32_i32$4;
-   wasm2asm_i32$1 = 13;
-   wasm2asm_i32$0 = FUNCTION_TABLE_iii[wasm2asm_i32$1 & 31](wasm2asm_i32$3 | 0, wasm2asm_i32$2 | 0) | 0;
-   i64toi32_i32$4 = wasm2asm_i32$0;
+   wasm2js_i32$3 = i64toi32_i32$0;
+   wasm2js_i32$2 = i64toi32_i32$4;
+   wasm2js_i32$1 = 13;
+   wasm2js_i32$0 = FUNCTION_TABLE_iii[wasm2js_i32$1 & 31](wasm2js_i32$3 | 0, wasm2js_i32$2 | 0) | 0;
+   i64toi32_i32$4 = wasm2js_i32$0;
    i64toi32_i32$2 = i64toi32_i32$HIGH_BITS;
    $8 = i64toi32_i32$4;
    $8$hi = i64toi32_i32$2;
@@ -396,44 +396,44 @@ function asmFunc(global, env, buffer) {
  
  function even($0) {
   $0 = $0 | 0;
-  var $6 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0;
+  var $6 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
   if (($0 | 0) == (0 | 0)) $6 = 44; else {
-   wasm2asm_i32$2 = $0 - 1 | 0;
-   wasm2asm_i32$1 = 15;
-   wasm2asm_i32$0 = FUNCTION_TABLE_ii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0) | 0;
-   $6 = wasm2asm_i32$0;
+   wasm2js_i32$2 = $0 - 1 | 0;
+   wasm2js_i32$1 = 15;
+   wasm2js_i32$0 = FUNCTION_TABLE_ii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0) | 0;
+   $6 = wasm2js_i32$0;
   }
   return $6 | 0;
  }
  
  function odd($0) {
   $0 = $0 | 0;
-  var $6 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0;
+  var $6 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
   if (($0 | 0) == (0 | 0)) $6 = 99; else {
-   wasm2asm_i32$2 = $0 - 1 | 0;
-   wasm2asm_i32$1 = 14;
-   wasm2asm_i32$0 = FUNCTION_TABLE_ii[wasm2asm_i32$1 & 31](wasm2asm_i32$2 | 0) | 0;
-   $6 = wasm2asm_i32$0;
+   wasm2js_i32$2 = $0 - 1 | 0;
+   wasm2js_i32$1 = 14;
+   wasm2js_i32$0 = FUNCTION_TABLE_ii[wasm2js_i32$1 & 31](wasm2js_i32$2 | 0) | 0;
+   $6 = wasm2js_i32$0;
   }
   return $6 | 0;
  }
  
  function runaway() {
-  var wasm2asm_i32$0 = 0;
-  wasm2asm_i32$0 = 16;
-  FUNCTION_TABLE_v[wasm2asm_i32$0 & 31]();
+  var wasm2js_i32$0 = 0;
+  wasm2js_i32$0 = 16;
+  FUNCTION_TABLE_v[wasm2js_i32$0 & 31]();
  }
  
  function mutual_runaway1() {
-  var wasm2asm_i32$0 = 0;
-  wasm2asm_i32$0 = 18;
-  FUNCTION_TABLE_v[wasm2asm_i32$0 & 31]();
+  var wasm2js_i32$0 = 0;
+  wasm2js_i32$0 = 18;
+  FUNCTION_TABLE_v[wasm2js_i32$0 & 31]();
  }
  
  function mutual_runaway2() {
-  var wasm2asm_i32$0 = 0;
-  wasm2asm_i32$0 = 17;
-  FUNCTION_TABLE_v[wasm2asm_i32$0 & 31]();
+  var wasm2js_i32$0 = 0;
+  wasm2js_i32$0 = 17;
+  FUNCTION_TABLE_v[wasm2js_i32$0 & 31]();
  }
  
  function _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE(var$0, var$0$hi, var$1, var$1$hi) {
@@ -570,3 +570,26 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const type_i32 = retasmFunc.type_i32;
+export const type_i64 = retasmFunc.type_i64;
+export const type_f32 = retasmFunc.type_f32;
+export const type_f64 = retasmFunc.type_f64;
+export const type_index = retasmFunc.type_index;
+export const type_first_i32 = retasmFunc.type_first_i32;
+export const type_first_i64 = retasmFunc.type_first_i64;
+export const type_first_f32 = retasmFunc.type_first_f32;
+export const type_first_f64 = retasmFunc.type_first_f64;
+export const type_second_i32 = retasmFunc.type_second_i32;
+export const type_second_i64 = retasmFunc.type_second_i64;
+export const type_second_f32 = retasmFunc.type_second_f32;
+export const type_second_f64 = retasmFunc.type_second_f64;
+export const dispatch = retasmFunc.dispatch;
+export const dispatch_structural = retasmFunc.dispatch_structural;
+export const fac = retasmFunc.fac;
+export const fib = retasmFunc.fib;
+export const even = retasmFunc.even;
+export const odd = retasmFunc.odd;
+export const runaway = retasmFunc.runaway;
+export const mutual_runaway = retasmFunc.mutual_runaway;
diff --git a/test/wasm2asm/comments.2asm.js b/test/wasm2js/comments.2asm.js
index db2cb8e82..c8ff78cb4 100644
--- a/test/wasm2asm/comments.2asm.js
+++ b/test/wasm2js/comments.2asm.js
@@ -26,3 +26,5 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
diff --git a/test/wasm2asm/conversions-modified.2asm.js b/test/wasm2js/conversions-modified.2asm.js
index 8a96d6f6b..3871c147b 100644
--- a/test/wasm2asm/conversions-modified.2asm.js
+++ b/test/wasm2js/conversions-modified.2asm.js
@@ -201,15 +201,15 @@ function asmFunc(global, env, buffer) {
  function $22(x, x$hi) {
   x = x | 0;
   x$hi = x$hi | 0;
-  var i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   i64toi32_i32$0 = x$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = x;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP32[(wasm2asm_i32$0 + 4 | 0) >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = x;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP32[(wasm2js_i32$0 + 4 | 0) >> 2] = wasm2js_i32$1;
   return +(+HEAPF64[0 >> 3]);
  }
  
@@ -220,10 +220,10 @@ function asmFunc(global, env, buffer) {
  
  function $24(x) {
   x = +x;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = x;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = x;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -260,3 +260,30 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const i64_extend_s_i32 = retasmFunc.i64_extend_s_i32;
+export const i64_extend_u_i32 = retasmFunc.i64_extend_u_i32;
+export const i32_wrap_i64 = retasmFunc.i32_wrap_i64;
+export const i32_trunc_s_f32 = retasmFunc.i32_trunc_s_f32;
+export const i32_trunc_u_f32 = retasmFunc.i32_trunc_u_f32;
+export const i32_trunc_s_f64 = retasmFunc.i32_trunc_s_f64;
+export const i32_trunc_u_f64 = retasmFunc.i32_trunc_u_f64;
+export const i64_trunc_s_f32 = retasmFunc.i64_trunc_s_f32;
+export const i64_trunc_u_f32 = retasmFunc.i64_trunc_u_f32;
+export const i64_trunc_s_f64 = retasmFunc.i64_trunc_s_f64;
+export const i64_trunc_u_f64 = retasmFunc.i64_trunc_u_f64;
+export const f32_convert_s_i32 = retasmFunc.f32_convert_s_i32;
+export const f32_convert_s_i64 = retasmFunc.f32_convert_s_i64;
+export const f64_convert_s_i32 = retasmFunc.f64_convert_s_i32;
+export const f64_convert_s_i64 = retasmFunc.f64_convert_s_i64;
+export const f32_convert_u_i32 = retasmFunc.f32_convert_u_i32;
+export const f32_convert_u_i64 = retasmFunc.f32_convert_u_i64;
+export const f64_convert_u_i32 = retasmFunc.f64_convert_u_i32;
+export const f64_convert_u_i64 = retasmFunc.f64_convert_u_i64;
+export const f64_promote_f32 = retasmFunc.f64_promote_f32;
+export const f32_demote_f64 = retasmFunc.f32_demote_f64;
+export const f32_reinterpret_i32 = retasmFunc.f32_reinterpret_i32;
+export const f64_reinterpret_i64 = retasmFunc.f64_reinterpret_i64;
+export const i32_reinterpret_f32 = retasmFunc.i32_reinterpret_f32;
+export const i64_reinterpret_f64 = retasmFunc.i64_reinterpret_f64;
diff --git a/test/wasm2asm/conversions-modified.wast b/test/wasm2js/conversions-modified.wast
index 4e410032b..4e410032b 100644
--- a/test/wasm2asm/conversions-modified.wast
+++ b/test/wasm2js/conversions-modified.wast
diff --git a/test/wasm2asm/empty_imported_table.2asm.js b/test/wasm2js/empty_imported_table.2asm.js
index de98258f1..de98258f1 100644
--- a/test/wasm2asm/empty_imported_table.2asm.js
+++ b/test/wasm2js/empty_imported_table.2asm.js
diff --git a/test/wasm2asm/empty_table.2asm.js b/test/wasm2js/empty_table.2asm.js
index db2cb8e82..c8ff78cb4 100644
--- a/test/wasm2asm/empty_table.2asm.js
+++ b/test/wasm2js/empty_table.2asm.js
@@ -26,3 +26,5 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
diff --git a/test/wasm2asm/endianness.2asm.js b/test/wasm2js/endianness.2asm.js
index f70ccfc0c..c4b830a30 100644
--- a/test/wasm2asm/endianness.2asm.js
+++ b/test/wasm2js/endianness.2asm.js
@@ -24,13 +24,13 @@ function asmFunc(global, env, buffer) {
  function i16_store_little(address, value) {
   address = address | 0;
   value = value | 0;
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = address;
-  wasm2asm_i32$1 = value;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = address + 1 | 0;
-  wasm2asm_i32$1 = value >>> 8 | 0;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = address;
+  wasm2js_i32$1 = value;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
+  wasm2js_i32$0 = address + 1 | 0;
+  wasm2js_i32$1 = value >>> 8 | 0;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
  }
  
  function i32_store_little(address, value) {
@@ -196,13 +196,13 @@ function asmFunc(global, env, buffer) {
  function $13(value, value$hi) {
   value = value | 0;
   value$hi = value$hi | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2asm_i32$0 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2js_i32$0 = 0;
   i64toi32_i32$0 = value$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64_store_little(0 | 0, value | 0, i64toi32_i32$0 | 0);
   i64toi32_i32$2 = 0;
   i64toi32_i32$0 = HEAPU32[i64toi32_i32$2 >> 2] | 0;
-  i64toi32_i32$1 = (wasm2asm_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2asm_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
+  i64toi32_i32$1 = (wasm2js_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2js_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$1 = i64toi32_i32$1;
@@ -219,10 +219,10 @@ function asmFunc(global, env, buffer) {
  
  function $15(value) {
   value = +value;
-  var i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = value;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = value;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64_store_little(0 | 0, HEAP32[0 >> 2] | 0 | 0, i64toi32_i32$0 | 0);
@@ -231,31 +231,31 @@ function asmFunc(global, env, buffer) {
  
  function $16(value) {
   value = value | 0;
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = value;
-  HEAP16[wasm2asm_i32$0 >> 1] = wasm2asm_i32$1;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = value;
+  HEAP16[wasm2js_i32$0 >> 1] = wasm2js_i32$1;
   return i16_load_little(0 | 0) | 0 | 0;
  }
  
  function $17(value) {
   value = value | 0;
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = value;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = value;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
   return i32_load_little(0 | 0) | 0 | 0;
  }
  
  function $18(value, value$hi) {
   value = value | 0;
   value$hi = value$hi | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   i64toi32_i32$0 = value$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = value;
-  HEAP16[wasm2asm_i32$0 >> 1] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = value;
+  HEAP16[wasm2js_i32$0 >> 1] = wasm2js_i32$1;
   i64toi32_i32$0 = 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -268,12 +268,12 @@ function asmFunc(global, env, buffer) {
  function $19(value, value$hi) {
   value = value | 0;
   value$hi = value$hi | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   i64toi32_i32$0 = value$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = value;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = value;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
   i64toi32_i32$0 = 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -286,16 +286,16 @@ function asmFunc(global, env, buffer) {
  function $20(value, value$hi) {
   value = value | 0;
   value$hi = value$hi | 0;
-  var i64toi32_i32$1 = 0, i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$1 = 0, i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   i64toi32_i32$0 = value$hi;
   i64toi32_i32$1 = 0;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = i64toi32_i32$1;
-  wasm2asm_i32$1 = value;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = i64toi32_i32$1;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+  wasm2js_i32$0 = i64toi32_i32$1;
+  wasm2js_i32$1 = value;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = i64toi32_i32$1;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
   i64toi32_i32$0 = i64_load_little(0 | 0) | 0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
   i64toi32_i32$1 = i64toi32_i32$1;
@@ -308,28 +308,28 @@ function asmFunc(global, env, buffer) {
  
  function $21(value) {
   value = Math_fround(value);
-  var wasm2asm_i32$0 = 0, wasm2asm_f32$0 = Math_fround(0);
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f32$0 = value;
-  HEAPF32[wasm2asm_i32$0 >> 2] = wasm2asm_f32$0;
+  var wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
+  wasm2js_i32$0 = 0;
+  wasm2js_f32$0 = value;
+  HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
   return Math_fround((HEAP32[0] = i32_load_little(0 | 0) | 0, HEAPF32[0]));
  }
  
  function $22(value) {
   value = +value;
-  var i64toi32_i32$1 = 0, i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = value;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$1 = 0, i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = value;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = i64_load_little(0 | 0) | 0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
   i64toi32_i32$1 = i64toi32_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$1;
-  HEAP32[(wasm2asm_i32$0 + 4 | 0) >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$1;
+  HEAP32[(wasm2js_i32$0 + 4 | 0) >> 2] = wasm2js_i32$1;
   return +(+HEAPF64[0 >> 3]);
  }
  
@@ -354,3 +354,22 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const i32_load16_s = retasmFunc.i32_load16_s;
+export const i32_load16_u = retasmFunc.i32_load16_u;
+export const i32_load = retasmFunc.i32_load;
+export const i64_load16_s = retasmFunc.i64_load16_s;
+export const i64_load16_u = retasmFunc.i64_load16_u;
+export const i64_load32_s = retasmFunc.i64_load32_s;
+export const i64_load32_u = retasmFunc.i64_load32_u;
+export const i64_load = retasmFunc.i64_load;
+export const f32_load = retasmFunc.f32_load;
+export const f64_load = retasmFunc.f64_load;
+export const i32_store16 = retasmFunc.i32_store16;
+export const i32_store = retasmFunc.i32_store;
+export const i64_store16 = retasmFunc.i64_store16;
+export const i64_store32 = retasmFunc.i64_store32;
+export const i64_store = retasmFunc.i64_store;
+export const f32_store = retasmFunc.f32_store;
+export const f64_store = retasmFunc.f64_store;
diff --git a/test/wasm2asm/f32.2asm.js b/test/wasm2js/f32.2asm.js
index 5b4fc1fdf..454fb8d8b 100644
--- a/test/wasm2asm/f32.2asm.js
+++ b/test/wasm2js/f32.2asm.js
@@ -100,22 +100,22 @@ function asmFunc(global, env, buffer) {
  
  function __wasm_nearest_f32(var$0) {
   var$0 = Math_fround(var$0);
-  var var$1 = Math_fround(0), var$2 = Math_fround(0), wasm2asm_f32$0 = Math_fround(0), wasm2asm_f32$1 = Math_fround(0), wasm2asm_i32$0 = 0;
+  var var$1 = Math_fround(0), var$2 = Math_fround(0), wasm2js_f32$0 = Math_fround(0), wasm2js_f32$1 = Math_fround(0), wasm2js_i32$0 = 0;
   var$1 = Math_fround(Math_floor(var$0));
   var$2 = Math_fround(var$0 - var$1);
   if ((var$2 < Math_fround(.5) | 0) == (0 | 0)) block : {
    var$0 = Math_fround(Math_ceil(var$0));
    if (var$2 > Math_fround(.5)) return Math_fround(var$0);
    var$2 = Math_fround(var$1 * Math_fround(.5));
-   var$1 = (wasm2asm_f32$0 = var$1, wasm2asm_f32$1 = var$0, wasm2asm_i32$0 = Math_fround(var$2 - Math_fround(Math_floor(var$2))) == Math_fround(0.0), wasm2asm_i32$0 ? wasm2asm_f32$0 : wasm2asm_f32$1);
+   var$1 = (wasm2js_f32$0 = var$1, wasm2js_f32$1 = var$0, wasm2js_i32$0 = Math_fround(var$2 - Math_fround(Math_floor(var$2))) == Math_fround(0.0), wasm2js_i32$0 ? wasm2js_f32$0 : wasm2js_f32$1);
   };
   return Math_fround(var$1);
  }
  
  function __wasm_trunc_f32(var$0) {
   var$0 = Math_fround(var$0);
-  var wasm2asm_f32$0 = Math_fround(0), wasm2asm_f32$1 = Math_fround(0), wasm2asm_i32$0 = 0;
-  return Math_fround((wasm2asm_f32$0 = Math_fround(Math_ceil(var$0)), wasm2asm_f32$1 = Math_fround(Math_floor(var$0)), wasm2asm_i32$0 = var$0 < Math_fround(0.0), wasm2asm_i32$0 ? wasm2asm_f32$0 : wasm2asm_f32$1));
+  var wasm2js_f32$0 = Math_fround(0), wasm2js_f32$1 = Math_fround(0), wasm2js_i32$0 = 0;
+  return Math_fround((wasm2js_f32$0 = Math_fround(Math_ceil(var$0)), wasm2js_f32$1 = Math_fround(Math_floor(var$0)), wasm2js_i32$0 = var$0 < Math_fround(0.0), wasm2js_i32$0 ? wasm2js_f32$0 : wasm2js_f32$1));
  }
  
  return {
@@ -136,3 +136,19 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const add = retasmFunc.add;
+export const sub = retasmFunc.sub;
+export const mul = retasmFunc.mul;
+export const div = retasmFunc.div;
+export const sqrt = retasmFunc.sqrt;
+export const min = retasmFunc.min;
+export const max = retasmFunc.max;
+export const ceil = retasmFunc.ceil;
+export const floor = retasmFunc.floor;
+export const trunc = retasmFunc.trunc;
+export const nearest = retasmFunc.nearest;
+export const abs = retasmFunc.abs;
+export const neg = retasmFunc.neg;
+export const copysign = retasmFunc.copysign;
diff --git a/test/wasm2asm/f32_cmp.2asm.js b/test/wasm2js/f32_cmp.2asm.js
index 4e10951b3..84bf67293 100644
--- a/test/wasm2asm/f32_cmp.2asm.js
+++ b/test/wasm2js/f32_cmp.2asm.js
@@ -67,3 +67,11 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const eq = retasmFunc.eq;
+export const ne = retasmFunc.ne;
+export const lt = retasmFunc.lt;
+export const le = retasmFunc.le;
+export const gt = retasmFunc.gt;
+export const ge = retasmFunc.ge;
diff --git a/test/wasm2asm/f64.2asm.js b/test/wasm2js/f64.2asm.js
index 2eca1d2b2..4ac679b72 100644
--- a/test/wasm2asm/f64.2asm.js
+++ b/test/wasm2js/f64.2asm.js
@@ -95,10 +95,10 @@ function asmFunc(global, env, buffer) {
  function $13(x, y) {
   x = +x;
   y = +y;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, $4_1 = 0, $4$hi = 0, $7_1 = 0, $7$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = x;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, $4_1 = 0, $4$hi = 0, $7_1 = 0, $7$hi = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = x;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$2 = HEAP32[0 >> 2] | 0;
@@ -107,9 +107,9 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$1 = i64toi32_i32$0 & i64toi32_i32$1 | 0;
   $4_1 = i64toi32_i32$2 & i64toi32_i32$3 | 0;
   $4$hi = i64toi32_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = y;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = y;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$1 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = HEAP32[0 >> 2] | 0;
@@ -124,33 +124,33 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$3 = $7_1;
   i64toi32_i32$0 = i64toi32_i32$2 | i64toi32_i32$0 | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$1 | i64toi32_i32$3 | 0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP32[(wasm2asm_i32$0 + 4 | 0) >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$1 | i64toi32_i32$3 | 0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP32[(wasm2js_i32$0 + 4 | 0) >> 2] = wasm2js_i32$1;
   return +(+HEAPF64[0 >> 3]);
  }
  
  function __wasm_nearest_f64(var$0) {
   var$0 = +var$0;
-  var var$1 = 0.0, var$2 = 0.0, wasm2asm_f64$0 = 0.0, wasm2asm_f64$1 = 0.0, wasm2asm_i32$0 = 0;
+  var var$1 = 0.0, var$2 = 0.0, wasm2js_f64$0 = 0.0, wasm2js_f64$1 = 0.0, wasm2js_i32$0 = 0;
   var$1 = Math_floor(var$0);
   var$2 = var$0 - var$1;
   if ((var$2 < .5 | 0) == (0 | 0)) block : {
    var$0 = Math_ceil(var$0);
    if (var$2 > .5) return +var$0;
    var$2 = var$1 * .5;
-   var$1 = (wasm2asm_f64$0 = var$1, wasm2asm_f64$1 = var$0, wasm2asm_i32$0 = var$2 - Math_floor(var$2) == 0.0, wasm2asm_i32$0 ? wasm2asm_f64$0 : wasm2asm_f64$1);
+   var$1 = (wasm2js_f64$0 = var$1, wasm2js_f64$1 = var$0, wasm2js_i32$0 = var$2 - Math_floor(var$2) == 0.0, wasm2js_i32$0 ? wasm2js_f64$0 : wasm2js_f64$1);
   };
   return +var$1;
  }
  
  function __wasm_trunc_f64(var$0) {
   var$0 = +var$0;
-  var wasm2asm_f64$0 = 0.0, wasm2asm_f64$1 = 0.0, wasm2asm_i32$0 = 0;
-  return +(wasm2asm_f64$0 = Math_ceil(var$0), wasm2asm_f64$1 = Math_floor(var$0), wasm2asm_i32$0 = var$0 < 0.0, wasm2asm_i32$0 ? wasm2asm_f64$0 : wasm2asm_f64$1);
+  var wasm2js_f64$0 = 0.0, wasm2js_f64$1 = 0.0, wasm2js_i32$0 = 0;
+  return +(wasm2js_f64$0 = Math_ceil(var$0), wasm2js_f64$1 = Math_floor(var$0), wasm2js_i32$0 = var$0 < 0.0, wasm2js_i32$0 ? wasm2js_f64$0 : wasm2js_f64$1);
  }
  
  return {
@@ -171,3 +171,19 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const add = retasmFunc.add;
+export const sub = retasmFunc.sub;
+export const mul = retasmFunc.mul;
+export const div = retasmFunc.div;
+export const sqrt = retasmFunc.sqrt;
+export const min = retasmFunc.min;
+export const max = retasmFunc.max;
+export const ceil = retasmFunc.ceil;
+export const floor = retasmFunc.floor;
+export const trunc = retasmFunc.trunc;
+export const nearest = retasmFunc.nearest;
+export const abs = retasmFunc.abs;
+export const neg = retasmFunc.neg;
+export const copysign = retasmFunc.copysign;
diff --git a/test/wasm2asm/f64_cmp.2asm.js b/test/wasm2js/f64_cmp.2asm.js
index 8da85a4ef..39b64c386 100644
--- a/test/wasm2asm/f64_cmp.2asm.js
+++ b/test/wasm2js/f64_cmp.2asm.js
@@ -67,3 +67,11 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const eq = retasmFunc.eq;
+export const ne = retasmFunc.ne;
+export const lt = retasmFunc.lt;
+export const le = retasmFunc.le;
+export const gt = retasmFunc.gt;
+export const ge = retasmFunc.ge;
diff --git a/test/wasm2asm/fac.2asm.js b/test/wasm2js/fac.2asm.js
index 6ad8376b0..3b35473f8 100644
--- a/test/wasm2asm/fac.2asm.js
+++ b/test/wasm2js/fac.2asm.js
@@ -366,3 +366,10 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const fac_rec = retasmFunc.fac_rec;
+export const fac_rec_named = retasmFunc.fac_rec_named;
+export const fac_iter = retasmFunc.fac_iter;
+export const fac_iter_named = retasmFunc.fac_iter_named;
+export const fac_opt = retasmFunc.fac_opt;
diff --git a/test/wasm2asm/float-ops.2asm.js b/test/wasm2js/float-ops.2asm.js
index b5f209705..946a763ba 100644
--- a/test/wasm2asm/float-ops.2asm.js
+++ b/test/wasm2js/float-ops.2asm.js
@@ -212,10 +212,10 @@ function asmFunc(global, env, buffer) {
  function copysign64($0, $1_1) {
   $0 = +$0;
   $1_1 = +$1_1;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, $4_1 = 0, $4$hi = 0, $7_1 = 0, $7$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = $0;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, $4_1 = 0, $4$hi = 0, $7_1 = 0, $7$hi = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = $0;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$2 = HEAP32[0 >> 2] | 0;
@@ -224,9 +224,9 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$1 = i64toi32_i32$0 & i64toi32_i32$1 | 0;
   $4_1 = i64toi32_i32$2 & i64toi32_i32$3 | 0;
   $4$hi = i64toi32_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = $1_1;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = $1_1;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$1 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = HEAP32[0 >> 2] | 0;
@@ -241,12 +241,12 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$3 = $7_1;
   i64toi32_i32$0 = i64toi32_i32$2 | i64toi32_i32$0 | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$1 | i64toi32_i32$3 | 0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP32[(wasm2asm_i32$0 + 4 | 0) >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$1 | i64toi32_i32$3 | 0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP32[(wasm2js_i32$0 + 4 | 0) >> 2] = wasm2js_i32$1;
   return +(+HEAPF64[0 >> 3]);
  }
  
@@ -436,3 +436,53 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const f32_add = retasmFunc.f32_add;
+export const f32_sub = retasmFunc.f32_sub;
+export const f32_mul = retasmFunc.f32_mul;
+export const f32_div = retasmFunc.f32_div;
+export const f64_add = retasmFunc.f64_add;
+export const f64_sub = retasmFunc.f64_sub;
+export const f64_mul = retasmFunc.f64_mul;
+export const f64_div = retasmFunc.f64_div;
+export const f32_eq = retasmFunc.f32_eq;
+export const f32_ne = retasmFunc.f32_ne;
+export const f32_ge = retasmFunc.f32_ge;
+export const f32_gt = retasmFunc.f32_gt;
+export const f32_le = retasmFunc.f32_le;
+export const f32_lt = retasmFunc.f32_lt;
+export const f64_eq = retasmFunc.f64_eq;
+export const f64_ne = retasmFunc.f64_ne;
+export const f64_ge = retasmFunc.f64_ge;
+export const f64_gt = retasmFunc.f64_gt;
+export const f64_le = retasmFunc.f64_le;
+export const f64_lt = retasmFunc.f64_lt;
+export const f32_min = retasmFunc.f32_min;
+export const f32_max = retasmFunc.f32_max;
+export const f64_min = retasmFunc.f64_min;
+export const f64_max = retasmFunc.f64_max;
+export const f64_promote = retasmFunc.f64_promote;
+export const f32_demote = retasmFunc.f32_demote;
+export const f32_floor = retasmFunc.f32_floor;
+export const f32_ceil = retasmFunc.f32_ceil;
+export const f64_floor = retasmFunc.f64_floor;
+export const f64_ceil = retasmFunc.f64_ceil;
+export const f32_sqrt = retasmFunc.f32_sqrt;
+export const f64_sqrt = retasmFunc.f64_sqrt;
+export const i32_to_f32 = retasmFunc.i32_to_f32;
+export const i32_to_f64 = retasmFunc.i32_to_f64;
+export const u32_to_f32 = retasmFunc.u32_to_f32;
+export const u32_to_f64 = retasmFunc.u32_to_f64;
+export const f32_to_i32 = retasmFunc.f32_to_i32;
+export const f64_to_i32 = retasmFunc.f64_to_i32;
+export const f32_to_u32 = retasmFunc.f32_to_u32;
+export const f64_to_u32 = retasmFunc.f64_to_u32;
+export const i64_to_f32 = retasmFunc.i64_to_f32;
+export const i64_to_f64 = retasmFunc.i64_to_f64;
+export const u64_to_f32 = retasmFunc.u64_to_f32;
+export const u64_to_f64 = retasmFunc.u64_to_f64;
+export const f32_to_i64 = retasmFunc.f32_to_i64;
+export const f64_to_i64 = retasmFunc.f64_to_i64;
+export const f32_to_u64 = retasmFunc.f32_to_u64;
+export const f64_to_u64 = retasmFunc.f64_to_u64;
diff --git a/test/wasm2asm/float-ops.wast b/test/wasm2js/float-ops.wast
index f724149cb..f724149cb 100644
--- a/test/wasm2asm/float-ops.wast
+++ b/test/wasm2js/float-ops.wast
diff --git a/test/wasm2asm/float_literals-modified.2asm.js b/test/wasm2js/float_literals-modified.2asm.js
index f3b1bd27e..3cc4147a0 100644
--- a/test/wasm2asm/float_literals-modified.2asm.js
+++ b/test/wasm2js/float_literals-modified.2asm.js
@@ -142,10 +142,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $30() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -154,10 +154,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $31() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -166,10 +166,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $32() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = -nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = -nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -178,10 +178,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $33() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -190,10 +190,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $34() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -202,10 +202,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $35() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = -nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = -nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -214,10 +214,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $36() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -226,10 +226,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $37() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -238,10 +238,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $38() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = -nan;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = -nan;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -250,10 +250,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $39() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = infinity;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = infinity;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -262,10 +262,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $40() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = infinity;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = infinity;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -274,10 +274,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $41() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = -infinity;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = -infinity;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -286,10 +286,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $42() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 0.0;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 0.0;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -298,10 +298,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $43() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 0.0;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 0.0;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -310,10 +310,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $44() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = -0.0;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = -0.0;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -322,10 +322,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $45() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 6.283185307179586;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 6.283185307179586;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -334,10 +334,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $46() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 5.0e-324;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 5.0e-324;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -346,10 +346,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $47() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 2.2250738585072014e-308;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 2.2250738585072014e-308;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -358,10 +358,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $48() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 2.225073858507201e-308;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 2.225073858507201e-308;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -370,10 +370,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $49() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 1797693134862315708145274.0e284;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 1797693134862315708145274.0e284;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -382,10 +382,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $50() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 1267650600228229401496703.0e6;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 1267650600228229401496703.0e6;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -394,10 +394,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $51() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 0.0;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 0.0;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -406,10 +406,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $52() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 0.0;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 0.0;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -418,10 +418,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $53() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = -0.0;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = -0.0;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -430,10 +430,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $54() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 6.283185307179586;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 6.283185307179586;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -442,10 +442,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $55() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 5.0e-324;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 5.0e-324;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -454,10 +454,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $56() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 2.2250738585072014e-308;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 2.2250738585072014e-308;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -466,10 +466,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $57() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 2.225073858507201e-308;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 2.225073858507201e-308;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -478,10 +478,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $58() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 1797693134862315708145274.0e284;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 1797693134862315708145274.0e284;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -490,10 +490,10 @@ function asmFunc(global, env, buffer) {
  }
  
  function $59() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = 1.e+100;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 1.e+100;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$1 = HEAP32[0 >> 2] | 0;
@@ -565,3 +565,65 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const f32_nan = retasmFunc.f32_nan;
+export const f32_positive_nan = retasmFunc.f32_positive_nan;
+export const f32_negative_nan = retasmFunc.f32_negative_nan;
+export const f32_plain_nan = retasmFunc.f32_plain_nan;
+export const f32_informally_known_as_plain_snan = retasmFunc.f32_informally_known_as_plain_snan;
+export const f32_all_ones_nan = retasmFunc.f32_all_ones_nan;
+export const f32_misc_nan = retasmFunc.f32_misc_nan;
+export const f32_misc_positive_nan = retasmFunc.f32_misc_positive_nan;
+export const f32_misc_negative_nan = retasmFunc.f32_misc_negative_nan;
+export const f32_infinity = retasmFunc.f32_infinity;
+export const f32_positive_infinity = retasmFunc.f32_positive_infinity;
+export const f32_negative_infinity = retasmFunc.f32_negative_infinity;
+export const f32_zero = retasmFunc.f32_zero;
+export const f32_positive_zero = retasmFunc.f32_positive_zero;
+export const f32_negative_zero = retasmFunc.f32_negative_zero;
+export const f32_misc = retasmFunc.f32_misc;
+export const f32_min_positive = retasmFunc.f32_min_positive;
+export const f32_min_normal = retasmFunc.f32_min_normal;
+export const f32_max_finite = retasmFunc.f32_max_finite;
+export const f32_max_subnormal = retasmFunc.f32_max_subnormal;
+export const f32_trailing_dot = retasmFunc.f32_trailing_dot;
+export const f32_dec_zero = retasmFunc.f32_dec_zero;
+export const f32_dec_positive_zero = retasmFunc.f32_dec_positive_zero;
+export const f32_dec_negative_zero = retasmFunc.f32_dec_negative_zero;
+export const f32_dec_misc = retasmFunc.f32_dec_misc;
+export const f32_dec_min_positive = retasmFunc.f32_dec_min_positive;
+export const f32_dec_min_normal = retasmFunc.f32_dec_min_normal;
+export const f32_dec_max_subnormal = retasmFunc.f32_dec_max_subnormal;
+export const f32_dec_max_finite = retasmFunc.f32_dec_max_finite;
+export const f32_dec_trailing_dot = retasmFunc.f32_dec_trailing_dot;
+export const f64_nan = retasmFunc.f64_nan;
+export const f64_positive_nan = retasmFunc.f64_positive_nan;
+export const f64_negative_nan = retasmFunc.f64_negative_nan;
+export const f64_plain_nan = retasmFunc.f64_plain_nan;
+export const f64_informally_known_as_plain_snan = retasmFunc.f64_informally_known_as_plain_snan;
+export const f64_all_ones_nan = retasmFunc.f64_all_ones_nan;
+export const f64_misc_nan = retasmFunc.f64_misc_nan;
+export const f64_misc_positive_nan = retasmFunc.f64_misc_positive_nan;
+export const f64_misc_negative_nan = retasmFunc.f64_misc_negative_nan;
+export const f64_infinity = retasmFunc.f64_infinity;
+export const f64_positive_infinity = retasmFunc.f64_positive_infinity;
+export const f64_negative_infinity = retasmFunc.f64_negative_infinity;
+export const f64_zero = retasmFunc.f64_zero;
+export const f64_positive_zero = retasmFunc.f64_positive_zero;
+export const f64_negative_zero = retasmFunc.f64_negative_zero;
+export const f64_misc = retasmFunc.f64_misc;
+export const f64_min_positive = retasmFunc.f64_min_positive;
+export const f64_min_normal = retasmFunc.f64_min_normal;
+export const f64_max_subnormal = retasmFunc.f64_max_subnormal;
+export const f64_max_finite = retasmFunc.f64_max_finite;
+export const f64_trailing_dot = retasmFunc.f64_trailing_dot;
+export const f64_dec_zero = retasmFunc.f64_dec_zero;
+export const f64_dec_positive_zero = retasmFunc.f64_dec_positive_zero;
+export const f64_dec_negative_zero = retasmFunc.f64_dec_negative_zero;
+export const f64_dec_misc = retasmFunc.f64_dec_misc;
+export const f64_dec_min_positive = retasmFunc.f64_dec_min_positive;
+export const f64_dec_min_normal = retasmFunc.f64_dec_min_normal;
+export const f64_dec_max_subnormal = retasmFunc.f64_dec_max_subnormal;
+export const f64_dec_max_finite = retasmFunc.f64_dec_max_finite;
+export const f64_dec_trailing_dot = retasmFunc.f64_dec_trailing_dot;
diff --git a/test/wasm2asm/float_literals-modified.wast b/test/wasm2js/float_literals-modified.wast
index aed4ab603..aed4ab603 100644
--- a/test/wasm2asm/float_literals-modified.wast
+++ b/test/wasm2js/float_literals-modified.wast
diff --git a/test/wasm2asm/float_misc.2asm.js b/test/wasm2js/float_misc.2asm.js
index ccff7ec44..7b5098c9d 100644
--- a/test/wasm2asm/float_misc.2asm.js
+++ b/test/wasm2js/float_misc.2asm.js
@@ -140,10 +140,10 @@ function asmFunc(global, env, buffer) {
  function $21(x, y) {
   x = +x;
   y = +y;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, $4_1 = 0, $4$hi = 0, $7_1 = 0, $7$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = x;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, $4_1 = 0, $4$hi = 0, $7_1 = 0, $7$hi = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = x;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$2 = HEAP32[0 >> 2] | 0;
@@ -152,9 +152,9 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$1 = i64toi32_i32$0 & i64toi32_i32$1 | 0;
   $4_1 = i64toi32_i32$2 & i64toi32_i32$3 | 0;
   $4$hi = i64toi32_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = y;
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = y;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$1 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = HEAP32[0 >> 2] | 0;
@@ -169,12 +169,12 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$3 = $7_1;
   i64toi32_i32$0 = i64toi32_i32$2 | i64toi32_i32$0 | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$1 | i64toi32_i32$3 | 0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP32[(wasm2asm_i32$0 + 4 | 0) >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$1 | i64toi32_i32$3 | 0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP32[(wasm2js_i32$0 + 4 | 0) >> 2] = wasm2js_i32$1;
   return +(+HEAPF64[0 >> 3]);
  }
  
@@ -212,42 +212,42 @@ function asmFunc(global, env, buffer) {
  
  function __wasm_nearest_f32(var$0) {
   var$0 = Math_fround(var$0);
-  var var$1 = Math_fround(0), var$2 = Math_fround(0), wasm2asm_f32$0 = Math_fround(0), wasm2asm_f32$1 = Math_fround(0), wasm2asm_i32$0 = 0;
+  var var$1 = Math_fround(0), var$2 = Math_fround(0), wasm2js_f32$0 = Math_fround(0), wasm2js_f32$1 = Math_fround(0), wasm2js_i32$0 = 0;
   var$1 = Math_fround(Math_floor(var$0));
   var$2 = Math_fround(var$0 - var$1);
   if ((var$2 < Math_fround(.5) | 0) == (0 | 0)) block : {
    var$0 = Math_fround(Math_ceil(var$0));
    if (var$2 > Math_fround(.5)) return Math_fround(var$0);
    var$2 = Math_fround(var$1 * Math_fround(.5));
-   var$1 = (wasm2asm_f32$0 = var$1, wasm2asm_f32$1 = var$0, wasm2asm_i32$0 = Math_fround(var$2 - Math_fround(Math_floor(var$2))) == Math_fround(0.0), wasm2asm_i32$0 ? wasm2asm_f32$0 : wasm2asm_f32$1);
+   var$1 = (wasm2js_f32$0 = var$1, wasm2js_f32$1 = var$0, wasm2js_i32$0 = Math_fround(var$2 - Math_fround(Math_floor(var$2))) == Math_fround(0.0), wasm2js_i32$0 ? wasm2js_f32$0 : wasm2js_f32$1);
   };
   return Math_fround(var$1);
  }
  
  function __wasm_nearest_f64(var$0) {
   var$0 = +var$0;
-  var var$1 = 0.0, var$2 = 0.0, wasm2asm_f64$0 = 0.0, wasm2asm_f64$1 = 0.0, wasm2asm_i32$0 = 0;
+  var var$1 = 0.0, var$2 = 0.0, wasm2js_f64$0 = 0.0, wasm2js_f64$1 = 0.0, wasm2js_i32$0 = 0;
   var$1 = Math_floor(var$0);
   var$2 = var$0 - var$1;
   if ((var$2 < .5 | 0) == (0 | 0)) block : {
    var$0 = Math_ceil(var$0);
    if (var$2 > .5) return +var$0;
    var$2 = var$1 * .5;
-   var$1 = (wasm2asm_f64$0 = var$1, wasm2asm_f64$1 = var$0, wasm2asm_i32$0 = var$2 - Math_floor(var$2) == 0.0, wasm2asm_i32$0 ? wasm2asm_f64$0 : wasm2asm_f64$1);
+   var$1 = (wasm2js_f64$0 = var$1, wasm2js_f64$1 = var$0, wasm2js_i32$0 = var$2 - Math_floor(var$2) == 0.0, wasm2js_i32$0 ? wasm2js_f64$0 : wasm2js_f64$1);
   };
   return +var$1;
  }
  
  function __wasm_trunc_f32(var$0) {
   var$0 = Math_fround(var$0);
-  var wasm2asm_f32$0 = Math_fround(0), wasm2asm_f32$1 = Math_fround(0), wasm2asm_i32$0 = 0;
-  return Math_fround((wasm2asm_f32$0 = Math_fround(Math_ceil(var$0)), wasm2asm_f32$1 = Math_fround(Math_floor(var$0)), wasm2asm_i32$0 = var$0 < Math_fround(0.0), wasm2asm_i32$0 ? wasm2asm_f32$0 : wasm2asm_f32$1));
+  var wasm2js_f32$0 = Math_fround(0), wasm2js_f32$1 = Math_fround(0), wasm2js_i32$0 = 0;
+  return Math_fround((wasm2js_f32$0 = Math_fround(Math_ceil(var$0)), wasm2js_f32$1 = Math_fround(Math_floor(var$0)), wasm2js_i32$0 = var$0 < Math_fround(0.0), wasm2js_i32$0 ? wasm2js_f32$0 : wasm2js_f32$1));
  }
  
  function __wasm_trunc_f64(var$0) {
   var$0 = +var$0;
-  var wasm2asm_f64$0 = 0.0, wasm2asm_f64$1 = 0.0, wasm2asm_i32$0 = 0;
-  return +(wasm2asm_f64$0 = Math_ceil(var$0), wasm2asm_f64$1 = Math_floor(var$0), wasm2asm_i32$0 = var$0 < 0.0, wasm2asm_i32$0 ? wasm2asm_f64$0 : wasm2asm_f64$1);
+  var wasm2js_f64$0 = 0.0, wasm2js_f64$1 = 0.0, wasm2js_i32$0 = 0;
+  return +(wasm2js_f64$0 = Math_ceil(var$0), wasm2js_f64$1 = Math_floor(var$0), wasm2js_i32$0 = var$0 < 0.0, wasm2js_i32$0 ? wasm2js_f64$0 : wasm2js_f64$1);
  }
  
  return {
@@ -282,3 +282,33 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const f32_add = retasmFunc.f32_add;
+export const f32_sub = retasmFunc.f32_sub;
+export const f32_mul = retasmFunc.f32_mul;
+export const f32_div = retasmFunc.f32_div;
+export const f32_sqrt = retasmFunc.f32_sqrt;
+export const f32_abs = retasmFunc.f32_abs;
+export const f32_neg = retasmFunc.f32_neg;
+export const f32_copysign = retasmFunc.f32_copysign;
+export const f32_ceil = retasmFunc.f32_ceil;
+export const f32_floor = retasmFunc.f32_floor;
+export const f32_trunc = retasmFunc.f32_trunc;
+export const f32_nearest = retasmFunc.f32_nearest;
+export const f32_min = retasmFunc.f32_min;
+export const f32_max = retasmFunc.f32_max;
+export const f64_add = retasmFunc.f64_add;
+export const f64_sub = retasmFunc.f64_sub;
+export const f64_mul = retasmFunc.f64_mul;
+export const f64_div = retasmFunc.f64_div;
+export const f64_sqrt = retasmFunc.f64_sqrt;
+export const f64_abs = retasmFunc.f64_abs;
+export const f64_neg = retasmFunc.f64_neg;
+export const f64_copysign = retasmFunc.f64_copysign;
+export const f64_ceil = retasmFunc.f64_ceil;
+export const f64_floor = retasmFunc.f64_floor;
+export const f64_trunc = retasmFunc.f64_trunc;
+export const f64_nearest = retasmFunc.f64_nearest;
+export const f64_min = retasmFunc.f64_min;
+export const f64_max = retasmFunc.f64_max;
diff --git a/test/wasm2asm/forward.2asm.js b/test/wasm2js/forward.2asm.js
index 51c7b19fc..dfdf6b2bf 100644
--- a/test/wasm2asm/forward.2asm.js
+++ b/test/wasm2js/forward.2asm.js
@@ -41,3 +41,7 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const even = retasmFunc.even;
+export const odd = retasmFunc.odd;
diff --git a/test/wasm2asm/func-ptr-offset.2asm.js b/test/wasm2js/func-ptr-offset.2asm.js
index f2cd80ed4..93b844826 100644
--- a/test/wasm2asm/func-ptr-offset.2asm.js
+++ b/test/wasm2js/func-ptr-offset.2asm.js
@@ -35,10 +35,10 @@ function asmFunc(global, env, buffer) {
  
  function $3($0) {
   $0 = $0 | 0;
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$1 = $0;
-  wasm2asm_i32$0 = FUNCTION_TABLE_i[wasm2asm_i32$1 & 3]() | 0;
-  return wasm2asm_i32$0 | 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$1 = $0;
+  wasm2js_i32$0 = FUNCTION_TABLE_i[wasm2js_i32$1 & 3]() | 0;
+  return wasm2js_i32$0 | 0;
  }
  
  var FUNCTION_TABLE_i = [t1, t1, t2, t3];
@@ -47,3 +47,6 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const call = retasmFunc.call;
diff --git a/test/wasm2asm/func-ptr-offset.wast b/test/wasm2js/func-ptr-offset.wast
index 1c9fdff26..1c9fdff26 100644
--- a/test/wasm2asm/func-ptr-offset.wast
+++ b/test/wasm2js/func-ptr-offset.wast
diff --git a/test/wasm2asm/func.2asm.js b/test/wasm2js/func.2asm.js
index dd738da52..0f6038ca0 100644
--- a/test/wasm2asm/func.2asm.js
+++ b/test/wasm2js/func.2asm.js
@@ -506,86 +506,86 @@ function asmFunc(global, env, buffer) {
  }
  
  function $76() {
-  var wasm2asm_i32$0 = 0;
-  wasm2asm_i32$0 = 1;
-  FUNCTION_TABLE_v[wasm2asm_i32$0 & 7]();
-  wasm2asm_i32$0 = 4;
-  FUNCTION_TABLE_v[wasm2asm_i32$0 & 7]();
+  var wasm2js_i32$0 = 0;
+  wasm2js_i32$0 = 1;
+  FUNCTION_TABLE_v[wasm2js_i32$0 & 7]();
+  wasm2js_i32$0 = 4;
+  FUNCTION_TABLE_v[wasm2js_i32$0 & 7]();
  }
  
  function $77() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_f64$1 = 0.0, wasm2asm_i32$3 = 0, wasm2asm_i32$4 = 0, wasm2asm_f64$2 = 0.0, wasm2asm_i32$5 = 0, wasm2asm_i32$6 = 0, wasm2asm_f32$0 = Math_fround(0), wasm2asm_i32$7 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_f64$1 = 0.0, wasm2js_i32$3 = 0, wasm2js_i32$4 = 0, wasm2js_f64$2 = 0.0, wasm2js_i32$5 = 0, wasm2js_i32$6 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$7 = 0;
   i64toi32_i32$0 = 0;
   i64toi32_i32$1 = 0;
   i64toi32_i32$2 = 0;
-  wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$1 = 0;
-  wasm2asm_i32$2 = i64toi32_i32$0;
-  wasm2asm_f64$1 = 0.0;
-  wasm2asm_i32$3 = 0;
-  wasm2asm_i32$4 = i64toi32_i32$1;
-  wasm2asm_f64$2 = 0.0;
-  wasm2asm_i32$5 = 0;
-  wasm2asm_i32$6 = i64toi32_i32$2;
-  wasm2asm_f32$0 = Math_fround(0.0);
-  wasm2asm_i32$7 = 0;
-  wasm2asm_i32$0 = 0;
-  FUNCTION_TABLE_vdiidiidiifi[wasm2asm_i32$0 & 7](+wasm2asm_f64$0, wasm2asm_i32$1 | 0, wasm2asm_i32$2 | 0, +wasm2asm_f64$1, wasm2asm_i32$3 | 0, wasm2asm_i32$4 | 0, +wasm2asm_f64$2, wasm2asm_i32$5 | 0, wasm2asm_i32$6 | 0, Math_fround(wasm2asm_f32$0), wasm2asm_i32$7 | 0);
+  wasm2js_f64$0 = 0.0;
+  wasm2js_i32$1 = 0;
+  wasm2js_i32$2 = i64toi32_i32$0;
+  wasm2js_f64$1 = 0.0;
+  wasm2js_i32$3 = 0;
+  wasm2js_i32$4 = i64toi32_i32$1;
+  wasm2js_f64$2 = 0.0;
+  wasm2js_i32$5 = 0;
+  wasm2js_i32$6 = i64toi32_i32$2;
+  wasm2js_f32$0 = Math_fround(0.0);
+  wasm2js_i32$7 = 0;
+  wasm2js_i32$0 = 0;
+  FUNCTION_TABLE_vdiidiidiifi[wasm2js_i32$0 & 7](+wasm2js_f64$0, wasm2js_i32$1 | 0, wasm2js_i32$2 | 0, +wasm2js_f64$1, wasm2js_i32$3 | 0, wasm2js_i32$4 | 0, +wasm2js_f64$2, wasm2js_i32$5 | 0, wasm2js_i32$6 | 0, Math_fround(wasm2js_f32$0), wasm2js_i32$7 | 0);
   i64toi32_i32$2 = 0;
   i64toi32_i32$1 = 0;
   i64toi32_i32$0 = 0;
-  wasm2asm_f64$2 = 0.0;
-  wasm2asm_i32$7 = 0;
-  wasm2asm_i32$6 = i64toi32_i32$2;
-  wasm2asm_f64$1 = 0.0;
-  wasm2asm_i32$5 = 0;
-  wasm2asm_i32$4 = i64toi32_i32$1;
-  wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$3 = 0;
-  wasm2asm_i32$2 = i64toi32_i32$0;
-  wasm2asm_f32$0 = Math_fround(0.0);
-  wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 2;
-  FUNCTION_TABLE_vdiidiidiifi[wasm2asm_i32$0 & 7](+wasm2asm_f64$2, wasm2asm_i32$7 | 0, wasm2asm_i32$6 | 0, +wasm2asm_f64$1, wasm2asm_i32$5 | 0, wasm2asm_i32$4 | 0, +wasm2asm_f64$0, wasm2asm_i32$3 | 0, wasm2asm_i32$2 | 0, Math_fround(wasm2asm_f32$0), wasm2asm_i32$1 | 0);
+  wasm2js_f64$2 = 0.0;
+  wasm2js_i32$7 = 0;
+  wasm2js_i32$6 = i64toi32_i32$2;
+  wasm2js_f64$1 = 0.0;
+  wasm2js_i32$5 = 0;
+  wasm2js_i32$4 = i64toi32_i32$1;
+  wasm2js_f64$0 = 0.0;
+  wasm2js_i32$3 = 0;
+  wasm2js_i32$2 = i64toi32_i32$0;
+  wasm2js_f32$0 = Math_fround(0.0);
+  wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 2;
+  FUNCTION_TABLE_vdiidiidiifi[wasm2js_i32$0 & 7](+wasm2js_f64$2, wasm2js_i32$7 | 0, wasm2js_i32$6 | 0, +wasm2js_f64$1, wasm2js_i32$5 | 0, wasm2js_i32$4 | 0, +wasm2js_f64$0, wasm2js_i32$3 | 0, wasm2js_i32$2 | 0, Math_fround(wasm2js_f32$0), wasm2js_i32$1 | 0);
   i64toi32_i32$0 = 0;
   i64toi32_i32$1 = 0;
   i64toi32_i32$2 = 0;
-  wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$1 = 0;
-  wasm2asm_i32$2 = i64toi32_i32$0;
-  wasm2asm_f64$1 = 0.0;
-  wasm2asm_i32$3 = 0;
-  wasm2asm_i32$4 = i64toi32_i32$1;
-  wasm2asm_f64$2 = 0.0;
-  wasm2asm_i32$5 = 0;
-  wasm2asm_i32$6 = i64toi32_i32$2;
-  wasm2asm_f32$0 = Math_fround(0.0);
-  wasm2asm_i32$7 = 0;
-  wasm2asm_i32$0 = 3;
-  FUNCTION_TABLE_vdiidiidiifi[wasm2asm_i32$0 & 7](+wasm2asm_f64$0, wasm2asm_i32$1 | 0, wasm2asm_i32$2 | 0, +wasm2asm_f64$1, wasm2asm_i32$3 | 0, wasm2asm_i32$4 | 0, +wasm2asm_f64$2, wasm2asm_i32$5 | 0, wasm2asm_i32$6 | 0, Math_fround(wasm2asm_f32$0), wasm2asm_i32$7 | 0);
+  wasm2js_f64$0 = 0.0;
+  wasm2js_i32$1 = 0;
+  wasm2js_i32$2 = i64toi32_i32$0;
+  wasm2js_f64$1 = 0.0;
+  wasm2js_i32$3 = 0;
+  wasm2js_i32$4 = i64toi32_i32$1;
+  wasm2js_f64$2 = 0.0;
+  wasm2js_i32$5 = 0;
+  wasm2js_i32$6 = i64toi32_i32$2;
+  wasm2js_f32$0 = Math_fround(0.0);
+  wasm2js_i32$7 = 0;
+  wasm2js_i32$0 = 3;
+  FUNCTION_TABLE_vdiidiidiifi[wasm2js_i32$0 & 7](+wasm2js_f64$0, wasm2js_i32$1 | 0, wasm2js_i32$2 | 0, +wasm2js_f64$1, wasm2js_i32$3 | 0, wasm2js_i32$4 | 0, +wasm2js_f64$2, wasm2js_i32$5 | 0, wasm2js_i32$6 | 0, Math_fround(wasm2js_f32$0), wasm2js_i32$7 | 0);
  }
  
  function $78() {
-  var wasm2asm_i32$0 = 0;
-  wasm2asm_i32$0 = 1;
-  FUNCTION_TABLE_v[wasm2asm_i32$0 & 7]();
+  var wasm2js_i32$0 = 0;
+  wasm2js_i32$0 = 1;
+  FUNCTION_TABLE_v[wasm2js_i32$0 & 7]();
  }
  
  function $79() {
-  var wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_f64$1 = 0.0, wasm2asm_i32$3 = 0, wasm2asm_i32$4 = 0, wasm2asm_f64$2 = 0.0, wasm2asm_i32$5 = 0, wasm2asm_i32$6 = 0, wasm2asm_f32$0 = Math_fround(0), wasm2asm_i32$7 = 0;
-  wasm2asm_f64$0 = 0.0;
-  wasm2asm_i32$1 = 0;
-  wasm2asm_i32$2 = 0;
-  wasm2asm_f64$1 = 0.0;
-  wasm2asm_i32$3 = 0;
-  wasm2asm_i32$4 = 0;
-  wasm2asm_f64$2 = 0.0;
-  wasm2asm_i32$5 = 0;
-  wasm2asm_i32$6 = 0;
-  wasm2asm_f32$0 = Math_fround(0.0);
-  wasm2asm_i32$7 = 0;
-  wasm2asm_i32$0 = 0;
-  FUNCTION_TABLE_vdiidiidiifi[wasm2asm_i32$0 & 7](+wasm2asm_f64$0, wasm2asm_i32$1 | 0, wasm2asm_i32$2 | 0, +wasm2asm_f64$1, wasm2asm_i32$3 | 0, wasm2asm_i32$4 | 0, +wasm2asm_f64$2, wasm2asm_i32$5 | 0, wasm2asm_i32$6 | 0, Math_fround(wasm2asm_f32$0), wasm2asm_i32$7 | 0);
+  var wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_f64$1 = 0.0, wasm2js_i32$3 = 0, wasm2js_i32$4 = 0, wasm2js_f64$2 = 0.0, wasm2js_i32$5 = 0, wasm2js_i32$6 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_i32$7 = 0;
+  wasm2js_f64$0 = 0.0;
+  wasm2js_i32$1 = 0;
+  wasm2js_i32$2 = 0;
+  wasm2js_f64$1 = 0.0;
+  wasm2js_i32$3 = 0;
+  wasm2js_i32$4 = 0;
+  wasm2js_f64$2 = 0.0;
+  wasm2js_i32$5 = 0;
+  wasm2js_i32$6 = 0;
+  wasm2js_f32$0 = Math_fround(0.0);
+  wasm2js_i32$7 = 0;
+  wasm2js_i32$0 = 0;
+  FUNCTION_TABLE_vdiidiidiifi[wasm2js_i32$0 & 7](+wasm2js_f64$0, wasm2js_i32$1 | 0, wasm2js_i32$2 | 0, +wasm2js_f64$1, wasm2js_i32$3 | 0, wasm2js_i32$4 | 0, +wasm2js_f64$2, wasm2js_i32$5 | 0, wasm2js_i32$6 | 0, Math_fround(wasm2js_f32$0), wasm2js_i32$7 | 0);
  }
  
  var FUNCTION_TABLE_v = [empty_sig_2, empty_sig_2, empty_sig_2, empty_sig_2, empty_sig_1, empty_sig_2, empty_sig_2, empty_sig_2];
@@ -648,3 +648,59 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const f = retasmFunc.f;
+export const g = retasmFunc.g;
+export const local_first_i32 = retasmFunc.local_first_i32;
+export const local_first_i64 = retasmFunc.local_first_i64;
+export const local_first_f32 = retasmFunc.local_first_f32;
+export const local_first_f64 = retasmFunc.local_first_f64;
+export const local_second_i32 = retasmFunc.local_second_i32;
+export const local_second_i64 = retasmFunc.local_second_i64;
+export const local_second_f32 = retasmFunc.local_second_f32;
+export const local_second_f64 = retasmFunc.local_second_f64;
+export const local_mixed = retasmFunc.local_mixed;
+export const param_first_i32 = retasmFunc.param_first_i32;
+export const param_first_i64 = retasmFunc.param_first_i64;
+export const param_first_f32 = retasmFunc.param_first_f32;
+export const param_first_f64 = retasmFunc.param_first_f64;
+export const param_second_i32 = retasmFunc.param_second_i32;
+export const param_second_i64 = retasmFunc.param_second_i64;
+export const param_second_f32 = retasmFunc.param_second_f32;
+export const param_second_f64 = retasmFunc.param_second_f64;
+export const param_mixed = retasmFunc.param_mixed;
+export const empty = retasmFunc.empty;
+export const value_void = retasmFunc.value_void;
+export const value_i32 = retasmFunc.value_i32;
+export const value_i64 = retasmFunc.value_i64;
+export const value_f32 = retasmFunc.value_f32;
+export const value_f64 = retasmFunc.value_f64;
+export const value_block_void = retasmFunc.value_block_void;
+export const value_block_i32 = retasmFunc.value_block_i32;
+export const return_empty = retasmFunc.return_empty;
+export const return_i32 = retasmFunc.return_i32;
+export const return_i64 = retasmFunc.return_i64;
+export const return_f32 = retasmFunc.return_f32;
+export const return_f64 = retasmFunc.return_f64;
+export const return_block_i32 = retasmFunc.return_block_i32;
+export const break_empty = retasmFunc.break_empty;
+export const break_i32 = retasmFunc.break_i32;
+export const break_i64 = retasmFunc.break_i64;
+export const break_f32 = retasmFunc.break_f32;
+export const break_f64 = retasmFunc.break_f64;
+export const break_block_i32 = retasmFunc.break_block_i32;
+export const break_br_if_empty = retasmFunc.break_br_if_empty;
+export const break_br_if_num = retasmFunc.break_br_if_num;
+export const break_br_table_empty = retasmFunc.break_br_table_empty;
+export const break_br_table_num = retasmFunc.break_br_table_num;
+export const break_br_table_nested_empty = retasmFunc.break_br_table_nested_empty;
+export const break_br_table_nested_num = retasmFunc.break_br_table_nested_num;
+export const init_local_i32 = retasmFunc.init_local_i32;
+export const init_local_i64 = retasmFunc.init_local_i64;
+export const init_local_f32 = retasmFunc.init_local_f32;
+export const init_local_f64 = retasmFunc.init_local_f64;
+export const signature_explicit_reused = retasmFunc.signature_explicit_reused;
+export const signature_implicit_reused = retasmFunc.signature_implicit_reused;
+export const signature_explicit_duplicate = retasmFunc.signature_explicit_duplicate;
+export const signature_implicit_duplicate = retasmFunc.signature_implicit_duplicate;
diff --git a/test/wasm2asm/func_ptrs.2asm.js b/test/wasm2js/func_ptrs.2asm.js
index b20b650a6..ec4d11d86 100644
--- a/test/wasm2asm/func_ptrs.2asm.js
+++ b/test/wasm2js/func_ptrs.2asm.js
@@ -1,3 +1,4 @@
+import { print } from 'spectest';
 function asmFunc(global, env, buffer) {
  "use asm";
  var HEAP8 = new global.Int8Array(buffer);
@@ -57,3 +58,9 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); },print},memasmFunc);
+export const one = retasmFunc.one;
+export const two = retasmFunc.two;
+export const three = retasmFunc.three;
+export const four = retasmFunc.four;
diff --git a/test/wasm2asm/get-set-local.2asm.js b/test/wasm2js/get-set-local.2asm.js
index 8dfd20a56..58c93ba2d 100644
--- a/test/wasm2asm/get-set-local.2asm.js
+++ b/test/wasm2js/get-set-local.2asm.js
@@ -46,3 +46,6 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const check_extend_ui32 = retasmFunc.check_extend_ui32;
diff --git a/test/wasm2asm/get-set-local.wast b/test/wasm2js/get-set-local.wast
index 1150c1e26..1150c1e26 100644
--- a/test/wasm2asm/get-set-local.wast
+++ b/test/wasm2js/get-set-local.wast
diff --git a/test/wasm2asm/get_local.2asm.js b/test/wasm2js/get_local.2asm.js
index 909861308..b88d35036 100644
--- a/test/wasm2asm/get_local.2asm.js
+++ b/test/wasm2js/get_local.2asm.js
@@ -123,3 +123,15 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const type_local_i32 = retasmFunc.type_local_i32;
+export const type_local_i64 = retasmFunc.type_local_i64;
+export const type_local_f32 = retasmFunc.type_local_f32;
+export const type_local_f64 = retasmFunc.type_local_f64;
+export const type_param_i32 = retasmFunc.type_param_i32;
+export const type_param_i64 = retasmFunc.type_param_i64;
+export const type_param_f32 = retasmFunc.type_param_f32;
+export const type_param_f64 = retasmFunc.type_param_f64;
+export const type_mixed = retasmFunc.type_mixed;
+export const read = retasmFunc.read;
diff --git a/test/wasm2asm/grow-memory-tricky.2asm.js b/test/wasm2js/grow-memory-tricky.2asm.js
index d82bfee97..3d5b9ec76 100644
--- a/test/wasm2asm/grow-memory-tricky.2asm.js
+++ b/test/wasm2js/grow-memory-tricky.2asm.js
@@ -22,18 +22,18 @@ function asmFunc(global, env, buffer) {
  var infinity = global.Infinity;
  var i64toi32_i32$HIGH_BITS = 0;
  function $0() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = __wasm_grow_memory(1 | 0);
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = __wasm_grow_memory(1 | 0);
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
   return HEAPU32[0 >> 2] | 0 | 0;
  }
  
  function $1() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = grow() | 0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = grow() | 0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
   return HEAPU32[0 >> 2] | 0 | 0;
  }
  
@@ -83,3 +83,8 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const memory = retasmFunc.memory;
+export const f1 = retasmFunc.f1;
+export const f2 = retasmFunc.f2;
diff --git a/test/wasm2asm/grow-memory-tricky.wast b/test/wasm2js/grow-memory-tricky.wast
index 7e249e502..7e249e502 100644
--- a/test/wasm2asm/grow-memory-tricky.wast
+++ b/test/wasm2js/grow-memory-tricky.wast
diff --git a/test/wasm2asm/grow_memory.2asm.js b/test/wasm2js/grow_memory.2asm.js
index 80341ab7b..db41919d2 100644
--- a/test/wasm2asm/grow_memory.2asm.js
+++ b/test/wasm2js/grow_memory.2asm.js
@@ -72,3 +72,8 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const memory = retasmFunc.memory;
+export const grow = retasmFunc.grow;
+export const current = retasmFunc.current;
diff --git a/test/wasm2asm/hello_world.2asm.js b/test/wasm2js/hello_world.2asm.js
index 957f7653d..9fef6f97c 100644
--- a/test/wasm2asm/hello_world.2asm.js
+++ b/test/wasm2js/hello_world.2asm.js
@@ -32,3 +32,6 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(16777216);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const add = retasmFunc.add;
diff --git a/test/wasm2asm/i32.2asm.js b/test/wasm2js/i32.2asm.js
index a8116d889..261f9df1c 100644
--- a/test/wasm2asm/i32.2asm.js
+++ b/test/wasm2js/i32.2asm.js
@@ -264,3 +264,34 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const add = retasmFunc.add;
+export const sub = retasmFunc.sub;
+export const mul = retasmFunc.mul;
+export const div_s = retasmFunc.div_s;
+export const div_u = retasmFunc.div_u;
+export const rem_s = retasmFunc.rem_s;
+export const rem_u = retasmFunc.rem_u;
+export const and = retasmFunc.and;
+export const or = retasmFunc.or;
+export const xor = retasmFunc.xor;
+export const shl = retasmFunc.shl;
+export const shr_s = retasmFunc.shr_s;
+export const shr_u = retasmFunc.shr_u;
+export const rotl = retasmFunc.rotl;
+export const rotr = retasmFunc.rotr;
+export const clz = retasmFunc.clz;
+export const ctz = retasmFunc.ctz;
+export const popcnt = retasmFunc.popcnt;
+export const eqz = retasmFunc.eqz;
+export const eq = retasmFunc.eq;
+export const ne = retasmFunc.ne;
+export const lt_s = retasmFunc.lt_s;
+export const lt_u = retasmFunc.lt_u;
+export const le_s = retasmFunc.le_s;
+export const le_u = retasmFunc.le_u;
+export const gt_s = retasmFunc.gt_s;
+export const gt_u = retasmFunc.gt_u;
+export const ge_s = retasmFunc.ge_s;
+export const ge_u = retasmFunc.ge_u;
diff --git a/test/wasm2asm/i64-add-sub.2asm.js b/test/wasm2js/i64-add-sub.2asm.js
index 1d150a7e3..62ef93b2f 100644
--- a/test/wasm2asm/i64-add-sub.2asm.js
+++ b/test/wasm2js/i64-add-sub.2asm.js
@@ -78,3 +78,7 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const check_add_i64 = retasmFunc.check_add_i64;
+export const check_sub_i64 = retasmFunc.check_sub_i64;
diff --git a/test/wasm2asm/i64-add-sub.wast b/test/wasm2js/i64-add-sub.wast
index b9ab45b79..b9ab45b79 100644
--- a/test/wasm2asm/i64-add-sub.wast
+++ b/test/wasm2js/i64-add-sub.wast
diff --git a/test/wasm2asm/i64-ctz.2asm.js b/test/wasm2js/i64-ctz.2asm.js
index 6923a0b0b..000203396 100644
--- a/test/wasm2asm/i64-ctz.2asm.js
+++ b/test/wasm2js/i64-ctz.2asm.js
@@ -159,3 +159,7 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const a = retasmFunc.a;
+export const b = retasmFunc.b;
diff --git a/test/wasm2asm/i64-ctz.wast b/test/wasm2js/i64-ctz.wast
index ce3a27d89..ce3a27d89 100644
--- a/test/wasm2asm/i64-ctz.wast
+++ b/test/wasm2js/i64-ctz.wast
diff --git a/test/wasm2asm/i64-lowering.2asm.js b/test/wasm2js/i64-lowering.2asm.js
index 61c50a841..9d673d20b 100644
--- a/test/wasm2asm/i64-lowering.2asm.js
+++ b/test/wasm2js/i64-lowering.2asm.js
@@ -199,3 +199,15 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const eq_i64 = retasmFunc.eq_i64;
+export const ne_i64 = retasmFunc.ne_i64;
+export const ge_s_i64 = retasmFunc.ge_s_i64;
+export const gt_s_i64 = retasmFunc.gt_s_i64;
+export const le_s_i64 = retasmFunc.le_s_i64;
+export const lt_s_i64 = retasmFunc.lt_s_i64;
+export const ge_u_i64 = retasmFunc.ge_u_i64;
+export const gt_u_i64 = retasmFunc.gt_u_i64;
+export const le_u_i64 = retasmFunc.le_u_i64;
+export const lt_u_i64 = retasmFunc.lt_u_i64;
diff --git a/test/wasm2asm/i64-lowering.wast b/test/wasm2js/i64-lowering.wast
index 1276b54c6..1276b54c6 100644
--- a/test/wasm2asm/i64-lowering.wast
+++ b/test/wasm2js/i64-lowering.wast
diff --git a/test/wasm2asm/i64-rotate.2asm.js b/test/wasm2js/i64-rotate.2asm.js
index 1fb594ba0..d7b07fb2a 100644
--- a/test/wasm2asm/i64-rotate.2asm.js
+++ b/test/wasm2js/i64-rotate.2asm.js
@@ -301,3 +301,7 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const rotl = retasmFunc.rotl;
+export const rotr = retasmFunc.rotr;
diff --git a/test/wasm2asm/i64-rotate.wast b/test/wasm2js/i64-rotate.wast
index 7de93b381..7de93b381 100644
--- a/test/wasm2asm/i64-rotate.wast
+++ b/test/wasm2js/i64-rotate.wast
diff --git a/test/wasm2asm/i64-shifts.2asm.js b/test/wasm2js/i64-shifts.2asm.js
index 3a9243fc0..919a1077e 100644
--- a/test/wasm2asm/i64-shifts.2asm.js
+++ b/test/wasm2js/i64-shifts.2asm.js
@@ -93,3 +93,7 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const shl_i64 = retasmFunc.shl_i64;
+export const shr_i64 = retasmFunc.shr_i64;
diff --git a/test/wasm2asm/i64-shifts.wast b/test/wasm2js/i64-shifts.wast
index d13c700ef..d13c700ef 100644
--- a/test/wasm2asm/i64-shifts.wast
+++ b/test/wasm2js/i64-shifts.wast
diff --git a/test/wasm2asm/i64.2asm.js b/test/wasm2js/i64.2asm.js
index 617414bbc..c61739d17 100644
--- a/test/wasm2asm/i64.2asm.js
+++ b/test/wasm2js/i64.2asm.js
@@ -840,7 +840,7 @@ function asmFunc(global, env, buffer) {
   var$0$hi = var$0$hi | 0;
   var$1 = var$1 | 0;
   var$1$hi = var$1$hi | 0;
-  var i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$0 = 0, i64toi32_i32$5 = 0, var$2 = 0, var$3 = 0, var$4 = 0, var$5 = 0, var$5$hi = 0, var$6 = 0, var$6$hi = 0, i64toi32_i32$6 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, var$8$hi = 0, $46 = 0, $47 = 0, $48 = 0, $49 = 0, var$7$hi = 0, $50 = 0, $63$hi = 0, $65 = 0, $65$hi = 0, $66 = 0, $120$hi = 0, $129$hi = 0, $134$hi = 0, var$8 = 0, $140 = 0, $140$hi = 0, $142$hi = 0, $144 = 0, $144$hi = 0, $151 = 0, $151$hi = 0, $154$hi = 0, var$7 = 0, $165$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$0 = 0, i64toi32_i32$5 = 0, var$2 = 0, var$3 = 0, var$4 = 0, var$5 = 0, var$5$hi = 0, var$6 = 0, var$6$hi = 0, i64toi32_i32$6 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, var$8$hi = 0, $46 = 0, $47 = 0, $48 = 0, $49 = 0, var$7$hi = 0, $50 = 0, $63$hi = 0, $65 = 0, $65$hi = 0, $66 = 0, $120$hi = 0, $129$hi = 0, $134$hi = 0, var$8 = 0, $140 = 0, $140$hi = 0, $142$hi = 0, $144 = 0, $144$hi = 0, $151 = 0, $151$hi = 0, $154$hi = 0, var$7 = 0, $165$hi = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   label$1 : {
    label$2 : {
     label$3 : {
@@ -908,12 +908,12 @@ function asmFunc(global, env, buffer) {
              i64toi32_i32$1 = 0;
              i64toi32_i32$2 = 1024;
              i64toi32_i32$1 = i64toi32_i32$1;
-             wasm2asm_i32$0 = i64toi32_i32$2;
-             wasm2asm_i32$1 = var$0 - Math_imul(var$2, var$3) | 0;
-             HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-             wasm2asm_i32$0 = i64toi32_i32$2;
-             wasm2asm_i32$1 = i64toi32_i32$1;
-             (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+             wasm2js_i32$0 = i64toi32_i32$2;
+             wasm2js_i32$1 = var$0 - Math_imul(var$2, var$3) | 0;
+             HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+             wasm2js_i32$0 = i64toi32_i32$2;
+             wasm2js_i32$1 = i64toi32_i32$1;
+             (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
              i64toi32_i32$1 = 0;
              i64toi32_i32$1 = i64toi32_i32$1;
              i64toi32_i32$2 = var$2;
@@ -971,12 +971,12 @@ function asmFunc(global, env, buffer) {
             $66 = i64toi32_i32$3 | i64toi32_i32$0 | 0;
             i64toi32_i32$3 = 1024;
             i64toi32_i32$1 = i64toi32_i32$1;
-            wasm2asm_i32$0 = i64toi32_i32$3;
-            wasm2asm_i32$1 = $66;
-            HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-            wasm2asm_i32$0 = i64toi32_i32$3;
-            wasm2asm_i32$1 = i64toi32_i32$1;
-            (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+            wasm2js_i32$0 = i64toi32_i32$3;
+            wasm2js_i32$1 = $66;
+            HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+            wasm2js_i32$0 = i64toi32_i32$3;
+            wasm2js_i32$1 = i64toi32_i32$1;
+            (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
             i64toi32_i32$1 = 0;
             i64toi32_i32$1 = i64toi32_i32$1;
             i64toi32_i32$3 = var$2 >>> ((__wasm_ctz_i32(var$3 | 0) | 0) & 31 | 0) | 0;
@@ -1010,12 +1010,12 @@ function asmFunc(global, env, buffer) {
         }
         i64toi32_i32$2 = 1024;
         i64toi32_i32$1 = i64toi32_i32$1;
-        wasm2asm_i32$0 = i64toi32_i32$2;
-        wasm2asm_i32$1 = $42;
-        HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-        wasm2asm_i32$0 = i64toi32_i32$2;
-        wasm2asm_i32$1 = i64toi32_i32$1;
-        (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+        wasm2js_i32$0 = i64toi32_i32$2;
+        wasm2js_i32$1 = $42;
+        HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+        wasm2js_i32$0 = i64toi32_i32$2;
+        wasm2js_i32$1 = i64toi32_i32$1;
+        (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
         i64toi32_i32$1 = 0;
         i64toi32_i32$1 = i64toi32_i32$1;
         i64toi32_i32$2 = var$4;
@@ -1031,12 +1031,12 @@ function asmFunc(global, env, buffer) {
       i64toi32_i32$2 = 0;
       i64toi32_i32$1 = 1024;
       i64toi32_i32$2 = i64toi32_i32$2;
-      wasm2asm_i32$0 = i64toi32_i32$1;
-      wasm2asm_i32$1 = var$4 & var$0 | 0;
-      HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-      wasm2asm_i32$0 = i64toi32_i32$1;
-      wasm2asm_i32$1 = i64toi32_i32$2;
-      (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+      wasm2js_i32$0 = i64toi32_i32$1;
+      wasm2js_i32$1 = var$4 & var$0 | 0;
+      HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+      wasm2js_i32$0 = i64toi32_i32$1;
+      wasm2js_i32$1 = i64toi32_i32$2;
+      (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
       if ((var$3 | 0) == (1 | 0)) break label$1;
       i64toi32_i32$2 = var$0$hi;
       i64toi32_i32$2 = 0;
@@ -1242,12 +1242,12 @@ function asmFunc(global, env, buffer) {
     i64toi32_i32$3 = var$5$hi;
     i64toi32_i32$2 = 1024;
     i64toi32_i32$3 = i64toi32_i32$3;
-    wasm2asm_i32$0 = i64toi32_i32$2;
-    wasm2asm_i32$1 = var$5;
-    HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-    wasm2asm_i32$0 = i64toi32_i32$2;
-    wasm2asm_i32$1 = i64toi32_i32$3;
-    (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+    wasm2js_i32$0 = i64toi32_i32$2;
+    wasm2js_i32$1 = var$5;
+    HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+    wasm2js_i32$0 = i64toi32_i32$2;
+    wasm2js_i32$1 = i64toi32_i32$3;
+    (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
     i64toi32_i32$3 = var$0$hi;
     i64toi32_i32$3 = i64toi32_i32$3;
     i64toi32_i32$5 = var$0;
@@ -1276,12 +1276,12 @@ function asmFunc(global, env, buffer) {
    i64toi32_i32$3 = var$0$hi;
    i64toi32_i32$5 = 1024;
    i64toi32_i32$3 = i64toi32_i32$3;
-   wasm2asm_i32$0 = i64toi32_i32$5;
-   wasm2asm_i32$1 = var$0;
-   HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-   wasm2asm_i32$0 = i64toi32_i32$5;
-   wasm2asm_i32$1 = i64toi32_i32$3;
-   (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+   wasm2js_i32$0 = i64toi32_i32$5;
+   wasm2js_i32$1 = var$0;
+   HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+   wasm2js_i32$0 = i64toi32_i32$5;
+   wasm2js_i32$1 = i64toi32_i32$3;
+   (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
    i64toi32_i32$3 = 0;
    var$0 = 0;
    var$0$hi = i64toi32_i32$3;
@@ -1420,7 +1420,7 @@ function asmFunc(global, env, buffer) {
   var$0$hi = var$0$hi | 0;
   var$1 = var$1 | 0;
   var$1$hi = var$1$hi | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2asm_i32$0 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2js_i32$0 = 0;
   i64toi32_i32$0 = var$0$hi;
   i64toi32_i32$0 = var$1$hi;
   i64toi32_i32$0 = var$0$hi;
@@ -1430,7 +1430,7 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$2 = 1024;
   i64toi32_i32$0 = HEAPU32[i64toi32_i32$2 >> 2] | 0;
-  i64toi32_i32$1 = (wasm2asm_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2asm_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
+  i64toi32_i32$1 = (wasm2js_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2js_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$1 = i64toi32_i32$1;
@@ -1760,3 +1760,34 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const add = retasmFunc.add;
+export const sub = retasmFunc.sub;
+export const mul = retasmFunc.mul;
+export const div_s = retasmFunc.div_s;
+export const div_u = retasmFunc.div_u;
+export const rem_s = retasmFunc.rem_s;
+export const rem_u = retasmFunc.rem_u;
+export const and = retasmFunc.and;
+export const or = retasmFunc.or;
+export const xor = retasmFunc.xor;
+export const shl = retasmFunc.shl;
+export const shr_s = retasmFunc.shr_s;
+export const shr_u = retasmFunc.shr_u;
+export const rotl = retasmFunc.rotl;
+export const rotr = retasmFunc.rotr;
+export const clz = retasmFunc.clz;
+export const ctz = retasmFunc.ctz;
+export const popcnt = retasmFunc.popcnt;
+export const eqz = retasmFunc.eqz;
+export const eq = retasmFunc.eq;
+export const ne = retasmFunc.ne;
+export const lt_s = retasmFunc.lt_s;
+export const lt_u = retasmFunc.lt_u;
+export const le_s = retasmFunc.le_s;
+export const le_u = retasmFunc.le_u;
+export const gt_s = retasmFunc.gt_s;
+export const gt_u = retasmFunc.gt_u;
+export const ge_s = retasmFunc.ge_s;
+export const ge_u = retasmFunc.ge_u;
diff --git a/test/wasm2asm/int_exprs.2asm.js b/test/wasm2js/int_exprs.2asm.js
index 661a324f0..749257bb1 100644
--- a/test/wasm2asm/int_exprs.2asm.js
+++ b/test/wasm2js/int_exprs.2asm.js
@@ -112,3 +112,9 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const i32_no_fold_cmp_s_offset = retasmFunc.i32_no_fold_cmp_s_offset;
+export const i32_no_fold_cmp_u_offset = retasmFunc.i32_no_fold_cmp_u_offset;
+export const i64_no_fold_cmp_s_offset = retasmFunc.i64_no_fold_cmp_s_offset;
+export const i64_no_fold_cmp_u_offset = retasmFunc.i64_no_fold_cmp_u_offset;
diff --git a/test/wasm2asm/int_literals.2asm.js b/test/wasm2js/int_literals.2asm.js
index 0a4401348..0d0b19f97 100644
--- a/test/wasm2asm/int_literals.2asm.js
+++ b/test/wasm2js/int_literals.2asm.js
@@ -152,3 +152,27 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const i32_test = retasmFunc.i32_test;
+export const i32_umax = retasmFunc.i32_umax;
+export const i32_smax = retasmFunc.i32_smax;
+export const i32_neg_smax = retasmFunc.i32_neg_smax;
+export const i32_smin = retasmFunc.i32_smin;
+export const i32_alt_smin = retasmFunc.i32_alt_smin;
+export const i32_inc_smin = retasmFunc.i32_inc_smin;
+export const i32_neg_zero = retasmFunc.i32_neg_zero;
+export const i32_not_octal = retasmFunc.i32_not_octal;
+export const i32_unsigned_decimal = retasmFunc.i32_unsigned_decimal;
+export const i32_plus_sign = retasmFunc.i32_plus_sign;
+export const i64_test = retasmFunc.i64_test;
+export const i64_umax = retasmFunc.i64_umax;
+export const i64_smax = retasmFunc.i64_smax;
+export const i64_neg_smax = retasmFunc.i64_neg_smax;
+export const i64_smin = retasmFunc.i64_smin;
+export const i64_alt_smin = retasmFunc.i64_alt_smin;
+export const i64_inc_smin = retasmFunc.i64_inc_smin;
+export const i64_neg_zero = retasmFunc.i64_neg_zero;
+export const i64_not_octal = retasmFunc.i64_not_octal;
+export const i64_unsigned_decimal = retasmFunc.i64_unsigned_decimal;
+export const i64_plus_sign = retasmFunc.i64_plus_sign;
diff --git a/test/wasm2asm/labels.2asm.js b/test/wasm2js/labels.2asm.js
index d42987ba9..e99b6db8e 100644
--- a/test/wasm2asm/labels.2asm.js
+++ b/test/wasm2js/labels.2asm.js
@@ -338,3 +338,22 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const block = retasmFunc.block;
+export const loop1 = retasmFunc.loop1;
+export const loop2 = retasmFunc.loop2;
+export const loop3 = retasmFunc.loop3;
+export const loop4 = retasmFunc.loop4;
+export const loop5 = retasmFunc.loop5;
+export const if_ = retasmFunc.if_;
+export const if2 = retasmFunc.if2;
+export const switch_ = retasmFunc.switch_;
+export const return_ = retasmFunc.return_;
+export const br_if0 = retasmFunc.br_if0;
+export const br_if1 = retasmFunc.br_if1;
+export const br_if2 = retasmFunc.br_if2;
+export const br_if3 = retasmFunc.br_if3;
+export const br = retasmFunc.br;
+export const shadowing = retasmFunc.shadowing;
+export const redefinition = retasmFunc.redefinition;
diff --git a/test/wasm2asm/left-to-right.2asm.js b/test/wasm2js/left-to-right.2asm.js
index 342893def..9b51b18bd 100644
--- a/test/wasm2asm/left-to-right.2asm.js
+++ b/test/wasm2js/left-to-right.2asm.js
@@ -74,26 +74,26 @@ function asmFunc(global, env, buffer) {
  }
  
  function reset() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
  }
  
  function bump() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
-  wasm2asm_i32$0 = 11;
-  wasm2asm_i32$1 = HEAPU8[10 >> 0] | 0;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 10;
-  wasm2asm_i32$1 = HEAPU8[9 >> 0] | 0;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 9;
-  wasm2asm_i32$1 = HEAPU8[8 >> 0] | 0;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 4294967293;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
+  wasm2js_i32$0 = 11;
+  wasm2js_i32$1 = HEAPU8[10 >> 0] | 0;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
+  wasm2js_i32$0 = 10;
+  wasm2js_i32$1 = HEAPU8[9 >> 0] | 0;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
+  wasm2js_i32$0 = 9;
+  wasm2js_i32$1 = HEAPU8[8 >> 0] | 0;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 4294967293;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
  }
  
  function get() {
@@ -101,56 +101,56 @@ function asmFunc(global, env, buffer) {
  }
  
  function i32_left() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 1;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 1;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 0 | 0;
  }
  
  function i32_right() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 2;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 2;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 1 | 0;
  }
  
  function i32_another() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 3;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 3;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 1 | 0;
  }
  
  function i32_callee() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 4;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 4;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 0 | 0;
  }
  
  function i32_bool() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 5;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 5;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 0 | 0;
  }
  
  function i64_left() {
-  var i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 1;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 1;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   i64toi32_i32$0 = 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -159,11 +159,11 @@ function asmFunc(global, env, buffer) {
  }
  
  function i64_right() {
-  var i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 2;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 2;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   i64toi32_i32$0 = 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -172,11 +172,11 @@ function asmFunc(global, env, buffer) {
  }
  
  function i64_another() {
-  var i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 3;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 3;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   i64toi32_i32$0 = 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$0 = i64toi32_i32$0;
@@ -185,110 +185,110 @@ function asmFunc(global, env, buffer) {
  }
  
  function i64_callee() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 4;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 4;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 2 | 0;
  }
  
  function i64_bool() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 5;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 5;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 0 | 0;
  }
  
  function f32_left() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 1;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 1;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return Math_fround(Math_fround(0.0));
  }
  
  function f32_right() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 2;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 2;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return Math_fround(Math_fround(1.0));
  }
  
  function f32_another() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 3;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 3;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return Math_fround(Math_fround(1.0));
  }
  
  function f32_callee() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 4;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 4;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 4 | 0;
  }
  
  function f32_bool() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 5;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 5;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 0 | 0;
  }
  
  function f64_left() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 1;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 1;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return +(0.0);
  }
  
  function f64_right() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 2;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 2;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return +(1.0);
  }
  
  function f64_another() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 3;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 3;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return +(1.0);
  }
  
  function f64_callee() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 4;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 4;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 6 | 0;
  }
  
  function f64_bool() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   bump();
-  wasm2asm_i32$0 = 8;
-  wasm2asm_i32$1 = 5;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 8;
+  wasm2js_i32$1 = 5;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return 0 | 0;
  }
  
@@ -453,29 +453,29 @@ function asmFunc(global, env, buffer) {
  }
  
  function $58() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   reset();
-  wasm2asm_i32$0 = i32_left() | 0;
-  wasm2asm_i32$1 = i32_right() | 0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = i32_left() | 0;
+  wasm2js_i32$1 = i32_right() | 0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
   return get() | 0 | 0;
  }
  
  function $59() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   reset();
-  wasm2asm_i32$0 = i32_left() | 0;
-  wasm2asm_i32$1 = i32_right() | 0;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = i32_left() | 0;
+  wasm2js_i32$1 = i32_right() | 0;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return get() | 0 | 0;
  }
  
  function $60() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   reset();
-  wasm2asm_i32$0 = i32_left() | 0;
-  wasm2asm_i32$1 = i32_right() | 0;
-  HEAP16[wasm2asm_i32$0 >> 1] = wasm2asm_i32$1;
+  wasm2js_i32$0 = i32_left() | 0;
+  wasm2js_i32$1 = i32_right() | 0;
+  HEAP16[wasm2js_i32$0 >> 1] = wasm2js_i32$1;
   return get() | 0 | 0;
  }
  
@@ -486,19 +486,19 @@ function asmFunc(global, env, buffer) {
  }
  
  function $62() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
   reset();
-  wasm2asm_i32$1 = i32_left() | 0;
-  wasm2asm_i32$2 = i32_right() | 0;
-  wasm2asm_i32$0 = i32_callee() | 0;
-  FUNCTION_TABLE_iii[wasm2asm_i32$0 & 7](wasm2asm_i32$1 | 0, wasm2asm_i32$2 | 0) | 0;
+  wasm2js_i32$1 = i32_left() | 0;
+  wasm2js_i32$2 = i32_right() | 0;
+  wasm2js_i32$0 = i32_callee() | 0;
+  FUNCTION_TABLE_iii[wasm2js_i32$0 & 7](wasm2js_i32$1 | 0, wasm2js_i32$2 | 0) | 0;
   return get() | 0 | 0;
  }
  
  function $63() {
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
   reset();
-  wasm2asm_i32$0 = i32_left() | 0, wasm2asm_i32$1 = i32_right() | 0, wasm2asm_i32$2 = i32_bool() | 0, wasm2asm_i32$2 ? wasm2asm_i32$0 : wasm2asm_i32$1;
+  wasm2js_i32$0 = i32_left() | 0, wasm2js_i32$1 = i32_right() | 0, wasm2js_i32$2 = i32_bool() | 0, wasm2js_i32$2 ? wasm2js_i32$0 : wasm2js_i32$1;
   return get() | 0 | 0;
  }
  
@@ -971,7 +971,7 @@ function asmFunc(global, env, buffer) {
  }
  
  function $87() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, $0 = 0, $1 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, $0 = 0, $1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   reset();
   $0 = i32_left() | 0;
   i64toi32_i32$0 = i64_right() | 0;
@@ -979,45 +979,45 @@ function asmFunc(global, env, buffer) {
   $1 = i64toi32_i32$0;
   i64toi32_i32$0 = $0;
   i64toi32_i32$1 = i64toi32_i32$1;
-  wasm2asm_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$1 = $1;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$1 = i64toi32_i32$1;
-  (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+  wasm2js_i32$0 = i64toi32_i32$0;
+  wasm2js_i32$1 = $1;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = i64toi32_i32$0;
+  wasm2js_i32$1 = i64toi32_i32$1;
+  (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
   return get() | 0 | 0;
  }
  
  function $88() {
-  var $0 = 0, i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var $0 = 0, i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   reset();
   $0 = i32_left() | 0;
   i64toi32_i32$0 = i64_right() | 0;
-  wasm2asm_i32$0 = $0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP8[wasm2asm_i32$0 >> 0] = wasm2asm_i32$1;
+  wasm2js_i32$0 = $0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP8[wasm2js_i32$0 >> 0] = wasm2js_i32$1;
   return get() | 0 | 0;
  }
  
  function $89() {
-  var $0 = 0, i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var $0 = 0, i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   reset();
   $0 = i32_left() | 0;
   i64toi32_i32$0 = i64_right() | 0;
-  wasm2asm_i32$0 = $0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP16[wasm2asm_i32$0 >> 1] = wasm2asm_i32$1;
+  wasm2js_i32$0 = $0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP16[wasm2js_i32$0 >> 1] = wasm2js_i32$1;
   return get() | 0 | 0;
  }
  
  function $90() {
-  var $0 = 0, i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0;
+  var $0 = 0, i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0;
   reset();
   $0 = i32_left() | 0;
   i64toi32_i32$0 = i64_right() | 0;
-  wasm2asm_i32$0 = $0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = $0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
   return get() | 0 | 0;
  }
  
@@ -1039,7 +1039,7 @@ function asmFunc(global, env, buffer) {
  }
  
  function $92() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, $0 = 0, $0$hi = 0, $1 = 0, $1$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0, wasm2asm_i32$4 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, $0 = 0, $0$hi = 0, $1 = 0, $1$hi = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0, wasm2js_i32$4 = 0;
   reset();
   i64toi32_i32$0 = i64_left() | 0;
   i64toi32_i32$1 = i64toi32_i32$HIGH_BITS;
@@ -1051,12 +1051,12 @@ function asmFunc(global, env, buffer) {
   $1$hi = i64toi32_i32$0;
   i64toi32_i32$0 = $0$hi;
   i64toi32_i32$1 = $1$hi;
-  wasm2asm_i32$1 = $0;
-  wasm2asm_i32$2 = i64toi32_i32$0;
-  wasm2asm_i32$3 = $1;
-  wasm2asm_i32$4 = i64toi32_i32$1;
-  wasm2asm_i32$0 = i64_callee() | 0;
-  FUNCTION_TABLE_iiiii[wasm2asm_i32$0 & 7](wasm2asm_i32$1 | 0, wasm2asm_i32$2 | 0, wasm2asm_i32$3 | 0, wasm2asm_i32$4 | 0) | 0;
+  wasm2js_i32$1 = $0;
+  wasm2js_i32$2 = i64toi32_i32$0;
+  wasm2js_i32$3 = $1;
+  wasm2js_i32$4 = i64toi32_i32$1;
+  wasm2js_i32$0 = i64_callee() | 0;
+  FUNCTION_TABLE_iiiii[wasm2js_i32$0 & 7](wasm2js_i32$1 | 0, wasm2js_i32$2 | 0, wasm2js_i32$3 | 0, wasm2js_i32$4 | 0) | 0;
   return get() | 0 | 0;
  }
  
@@ -1158,11 +1158,11 @@ function asmFunc(global, env, buffer) {
  }
  
  function $107() {
-  var wasm2asm_i32$0 = 0, wasm2asm_f32$0 = Math_fround(0);
+  var wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0);
   reset();
-  wasm2asm_i32$0 = i32_left() | 0;
-  wasm2asm_f32$0 = Math_fround(f32_right());
-  HEAPF32[wasm2asm_i32$0 >> 2] = wasm2asm_f32$0;
+  wasm2js_i32$0 = i32_left() | 0;
+  wasm2js_f32$0 = Math_fround(f32_right());
+  HEAPF32[wasm2js_i32$0 >> 2] = wasm2js_f32$0;
   return get() | 0 | 0;
  }
  
@@ -1173,19 +1173,19 @@ function asmFunc(global, env, buffer) {
  }
  
  function $109() {
-  var wasm2asm_i32$0 = 0, wasm2asm_f32$0 = Math_fround(0), wasm2asm_f32$1 = Math_fround(0);
+  var wasm2js_i32$0 = 0, wasm2js_f32$0 = Math_fround(0), wasm2js_f32$1 = Math_fround(0);
   reset();
-  wasm2asm_f32$0 = Math_fround(f32_left());
-  wasm2asm_f32$1 = Math_fround(f32_right());
-  wasm2asm_i32$0 = f32_callee() | 0;
-  FUNCTION_TABLE_iff[wasm2asm_i32$0 & 7](Math_fround(wasm2asm_f32$0), Math_fround(wasm2asm_f32$1)) | 0;
+  wasm2js_f32$0 = Math_fround(f32_left());
+  wasm2js_f32$1 = Math_fround(f32_right());
+  wasm2js_i32$0 = f32_callee() | 0;
+  FUNCTION_TABLE_iff[wasm2js_i32$0 & 7](Math_fround(wasm2js_f32$0), Math_fround(wasm2js_f32$1)) | 0;
   return get() | 0 | 0;
  }
  
  function $110() {
-  var wasm2asm_f32$0 = Math_fround(0), wasm2asm_f32$1 = Math_fround(0), wasm2asm_i32$0 = 0;
+  var wasm2js_f32$0 = Math_fround(0), wasm2js_f32$1 = Math_fround(0), wasm2js_i32$0 = 0;
   reset();
-  wasm2asm_f32$0 = Math_fround(f32_left()), wasm2asm_f32$1 = Math_fround(f32_right()), wasm2asm_i32$0 = f32_bool() | 0, wasm2asm_i32$0 ? wasm2asm_f32$0 : wasm2asm_f32$1;
+  wasm2js_f32$0 = Math_fround(f32_left()), wasm2js_f32$1 = Math_fround(f32_right()), wasm2js_i32$0 = f32_bool() | 0, wasm2js_i32$0 ? wasm2js_f32$0 : wasm2js_f32$1;
   return get() | 0 | 0;
  }
  
@@ -1214,11 +1214,11 @@ function asmFunc(global, env, buffer) {
  }
  
  function $115() {
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, $2 = 0, $2$hi = 0, $5 = 0, $5$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_i32$1 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, $2 = 0, $2$hi = 0, $5 = 0, $5$hi = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_i32$1 = 0;
   reset();
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = +f64_left();
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = +f64_left();
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$2 = HEAP32[0 >> 2] | 0;
@@ -1227,9 +1227,9 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$1 = i64toi32_i32$0 & i64toi32_i32$1 | 0;
   $2 = i64toi32_i32$2 & i64toi32_i32$3 | 0;
   $2$hi = i64toi32_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = +f64_right();
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = +f64_right();
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$1 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$0 = HEAP32[0 >> 2] | 0;
@@ -1244,12 +1244,12 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$3 = $5;
   i64toi32_i32$0 = i64toi32_i32$2 | i64toi32_i32$0 | 0;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$1 | i64toi32_i32$3 | 0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP32[(wasm2asm_i32$0 + 4 | 0) >> 2] = wasm2asm_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$1 | i64toi32_i32$3 | 0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP32[(wasm2js_i32$0 + 4 | 0) >> 2] = wasm2js_i32$1;
   +HEAPF64[0 >> 3];
   return get() | 0 | 0;
  }
@@ -1303,11 +1303,11 @@ function asmFunc(global, env, buffer) {
  }
  
  function $124() {
-  var wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0;
+  var wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0;
   reset();
-  wasm2asm_i32$0 = i32_left() | 0;
-  wasm2asm_f64$0 = +f64_right();
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  wasm2js_i32$0 = i32_left() | 0;
+  wasm2js_f64$0 = +f64_right();
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   return get() | 0 | 0;
  }
  
@@ -1318,19 +1318,19 @@ function asmFunc(global, env, buffer) {
  }
  
  function $126() {
-  var wasm2asm_i32$0 = 0, wasm2asm_f64$0 = 0.0, wasm2asm_f64$1 = 0.0;
+  var wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_f64$1 = 0.0;
   reset();
-  wasm2asm_f64$0 = +f64_left();
-  wasm2asm_f64$1 = +f64_right();
-  wasm2asm_i32$0 = f64_callee() | 0;
-  FUNCTION_TABLE_idd[wasm2asm_i32$0 & 7](+wasm2asm_f64$0, +wasm2asm_f64$1) | 0;
+  wasm2js_f64$0 = +f64_left();
+  wasm2js_f64$1 = +f64_right();
+  wasm2js_i32$0 = f64_callee() | 0;
+  FUNCTION_TABLE_idd[wasm2js_i32$0 & 7](+wasm2js_f64$0, +wasm2js_f64$1) | 0;
   return get() | 0 | 0;
  }
  
  function $127() {
-  var wasm2asm_f64$0 = 0.0, wasm2asm_f64$1 = 0.0, wasm2asm_i32$0 = 0;
+  var wasm2js_f64$0 = 0.0, wasm2js_f64$1 = 0.0, wasm2js_i32$0 = 0;
   reset();
-  wasm2asm_f64$0 = +f64_left(), wasm2asm_f64$1 = +f64_right(), wasm2asm_i32$0 = f64_bool() | 0, wasm2asm_i32$0 ? wasm2asm_f64$0 : wasm2asm_f64$1;
+  wasm2js_f64$0 = +f64_left(), wasm2js_f64$1 = +f64_right(), wasm2js_i32$0 = f64_bool() | 0, wasm2js_i32$0 ? wasm2js_f64$0 : wasm2js_f64$1;
   return get() | 0 | 0;
  }
  
@@ -1676,7 +1676,7 @@ function asmFunc(global, env, buffer) {
   var$0$hi = var$0$hi | 0;
   var$1 = var$1 | 0;
   var$1$hi = var$1$hi | 0;
-  var i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$0 = 0, i64toi32_i32$5 = 0, var$2 = 0, var$3 = 0, var$4 = 0, var$5 = 0, var$5$hi = 0, var$6 = 0, var$6$hi = 0, i64toi32_i32$6 = 0, $38_1 = 0, $39_1 = 0, $40_1 = 0, $41_1 = 0, $42_1 = 0, $43_1 = 0, $44_1 = 0, $45_1 = 0, var$8$hi = 0, $46_1 = 0, $47_1 = 0, $48_1 = 0, $49_1 = 0, var$7$hi = 0, $50_1 = 0, $63$hi = 0, $65_1 = 0, $65$hi = 0, $66_1 = 0, $120$hi = 0, $129$hi = 0, $134$hi = 0, var$8 = 0, $140 = 0, $140$hi = 0, $142$hi = 0, $144 = 0, $144$hi = 0, $151 = 0, $151$hi = 0, $154$hi = 0, var$7 = 0, $165$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$0 = 0, i64toi32_i32$5 = 0, var$2 = 0, var$3 = 0, var$4 = 0, var$5 = 0, var$5$hi = 0, var$6 = 0, var$6$hi = 0, i64toi32_i32$6 = 0, $38_1 = 0, $39_1 = 0, $40_1 = 0, $41_1 = 0, $42_1 = 0, $43_1 = 0, $44_1 = 0, $45_1 = 0, var$8$hi = 0, $46_1 = 0, $47_1 = 0, $48_1 = 0, $49_1 = 0, var$7$hi = 0, $50_1 = 0, $63$hi = 0, $65_1 = 0, $65$hi = 0, $66_1 = 0, $120$hi = 0, $129$hi = 0, $134$hi = 0, var$8 = 0, $140 = 0, $140$hi = 0, $142$hi = 0, $144 = 0, $144$hi = 0, $151 = 0, $151$hi = 0, $154$hi = 0, var$7 = 0, $165$hi = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   label$1 : {
    label$2 : {
     label$3 : {
@@ -1744,12 +1744,12 @@ function asmFunc(global, env, buffer) {
              i64toi32_i32$1 = 0;
              i64toi32_i32$2 = 1024;
              i64toi32_i32$1 = i64toi32_i32$1;
-             wasm2asm_i32$0 = i64toi32_i32$2;
-             wasm2asm_i32$1 = var$0 - Math_imul(var$2, var$3) | 0;
-             HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-             wasm2asm_i32$0 = i64toi32_i32$2;
-             wasm2asm_i32$1 = i64toi32_i32$1;
-             (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+             wasm2js_i32$0 = i64toi32_i32$2;
+             wasm2js_i32$1 = var$0 - Math_imul(var$2, var$3) | 0;
+             HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+             wasm2js_i32$0 = i64toi32_i32$2;
+             wasm2js_i32$1 = i64toi32_i32$1;
+             (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
              i64toi32_i32$1 = 0;
              i64toi32_i32$1 = i64toi32_i32$1;
              i64toi32_i32$2 = var$2;
@@ -1807,12 +1807,12 @@ function asmFunc(global, env, buffer) {
             $66_1 = i64toi32_i32$3 | i64toi32_i32$0 | 0;
             i64toi32_i32$3 = 1024;
             i64toi32_i32$1 = i64toi32_i32$1;
-            wasm2asm_i32$0 = i64toi32_i32$3;
-            wasm2asm_i32$1 = $66_1;
-            HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-            wasm2asm_i32$0 = i64toi32_i32$3;
-            wasm2asm_i32$1 = i64toi32_i32$1;
-            (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+            wasm2js_i32$0 = i64toi32_i32$3;
+            wasm2js_i32$1 = $66_1;
+            HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+            wasm2js_i32$0 = i64toi32_i32$3;
+            wasm2js_i32$1 = i64toi32_i32$1;
+            (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
             i64toi32_i32$1 = 0;
             i64toi32_i32$1 = i64toi32_i32$1;
             i64toi32_i32$3 = var$2 >>> ((__wasm_ctz_i32(var$3 | 0) | 0) & 31 | 0) | 0;
@@ -1846,12 +1846,12 @@ function asmFunc(global, env, buffer) {
         }
         i64toi32_i32$2 = 1024;
         i64toi32_i32$1 = i64toi32_i32$1;
-        wasm2asm_i32$0 = i64toi32_i32$2;
-        wasm2asm_i32$1 = $42_1;
-        HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-        wasm2asm_i32$0 = i64toi32_i32$2;
-        wasm2asm_i32$1 = i64toi32_i32$1;
-        (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+        wasm2js_i32$0 = i64toi32_i32$2;
+        wasm2js_i32$1 = $42_1;
+        HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+        wasm2js_i32$0 = i64toi32_i32$2;
+        wasm2js_i32$1 = i64toi32_i32$1;
+        (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
         i64toi32_i32$1 = 0;
         i64toi32_i32$1 = i64toi32_i32$1;
         i64toi32_i32$2 = var$4;
@@ -1867,12 +1867,12 @@ function asmFunc(global, env, buffer) {
       i64toi32_i32$2 = 0;
       i64toi32_i32$1 = 1024;
       i64toi32_i32$2 = i64toi32_i32$2;
-      wasm2asm_i32$0 = i64toi32_i32$1;
-      wasm2asm_i32$1 = var$4 & var$0 | 0;
-      HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-      wasm2asm_i32$0 = i64toi32_i32$1;
-      wasm2asm_i32$1 = i64toi32_i32$2;
-      (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+      wasm2js_i32$0 = i64toi32_i32$1;
+      wasm2js_i32$1 = var$4 & var$0 | 0;
+      HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+      wasm2js_i32$0 = i64toi32_i32$1;
+      wasm2js_i32$1 = i64toi32_i32$2;
+      (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
       if ((var$3 | 0) == (1 | 0)) break label$1;
       i64toi32_i32$2 = var$0$hi;
       i64toi32_i32$2 = 0;
@@ -2078,12 +2078,12 @@ function asmFunc(global, env, buffer) {
     i64toi32_i32$3 = var$5$hi;
     i64toi32_i32$2 = 1024;
     i64toi32_i32$3 = i64toi32_i32$3;
-    wasm2asm_i32$0 = i64toi32_i32$2;
-    wasm2asm_i32$1 = var$5;
-    HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-    wasm2asm_i32$0 = i64toi32_i32$2;
-    wasm2asm_i32$1 = i64toi32_i32$3;
-    (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+    wasm2js_i32$0 = i64toi32_i32$2;
+    wasm2js_i32$1 = var$5;
+    HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+    wasm2js_i32$0 = i64toi32_i32$2;
+    wasm2js_i32$1 = i64toi32_i32$3;
+    (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
     i64toi32_i32$3 = var$0$hi;
     i64toi32_i32$3 = i64toi32_i32$3;
     i64toi32_i32$5 = var$0;
@@ -2112,12 +2112,12 @@ function asmFunc(global, env, buffer) {
    i64toi32_i32$3 = var$0$hi;
    i64toi32_i32$5 = 1024;
    i64toi32_i32$3 = i64toi32_i32$3;
-   wasm2asm_i32$0 = i64toi32_i32$5;
-   wasm2asm_i32$1 = var$0;
-   HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-   wasm2asm_i32$0 = i64toi32_i32$5;
-   wasm2asm_i32$1 = i64toi32_i32$3;
-   (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+   wasm2js_i32$0 = i64toi32_i32$5;
+   wasm2js_i32$1 = var$0;
+   HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+   wasm2js_i32$0 = i64toi32_i32$5;
+   wasm2js_i32$1 = i64toi32_i32$3;
+   (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
    i64toi32_i32$3 = 0;
    var$0 = 0;
    var$0$hi = i64toi32_i32$3;
@@ -2208,7 +2208,7 @@ function asmFunc(global, env, buffer) {
   var$0$hi = var$0$hi | 0;
   var$1 = var$1 | 0;
   var$1$hi = var$1$hi | 0;
-  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2asm_i32$0 = 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2js_i32$0 = 0;
   i64toi32_i32$0 = var$0$hi;
   i64toi32_i32$0 = var$1$hi;
   i64toi32_i32$0 = var$0$hi;
@@ -2218,7 +2218,7 @@ function asmFunc(global, env, buffer) {
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$2 = 1024;
   i64toi32_i32$0 = HEAPU32[i64toi32_i32$2 >> 2] | 0;
-  i64toi32_i32$1 = (wasm2asm_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2asm_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2asm_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2asm_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2asm_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
+  i64toi32_i32$1 = (wasm2js_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2js_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$1 = i64toi32_i32$1;
   i64toi32_i32$1 = i64toi32_i32$1;
@@ -2336,3 +2336,100 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const i32_add = retasmFunc.i32_add;
+export const i32_sub = retasmFunc.i32_sub;
+export const i32_mul = retasmFunc.i32_mul;
+export const i32_div_s = retasmFunc.i32_div_s;
+export const i32_div_u = retasmFunc.i32_div_u;
+export const i32_rem_s = retasmFunc.i32_rem_s;
+export const i32_rem_u = retasmFunc.i32_rem_u;
+export const i32_and = retasmFunc.i32_and;
+export const i32_or = retasmFunc.i32_or;
+export const i32_xor = retasmFunc.i32_xor;
+export const i32_shl = retasmFunc.i32_shl;
+export const i32_shr_u = retasmFunc.i32_shr_u;
+export const i32_shr_s = retasmFunc.i32_shr_s;
+export const i32_eq = retasmFunc.i32_eq;
+export const i32_ne = retasmFunc.i32_ne;
+export const i32_lt_s = retasmFunc.i32_lt_s;
+export const i32_le_s = retasmFunc.i32_le_s;
+export const i32_lt_u = retasmFunc.i32_lt_u;
+export const i32_le_u = retasmFunc.i32_le_u;
+export const i32_gt_s = retasmFunc.i32_gt_s;
+export const i32_ge_s = retasmFunc.i32_ge_s;
+export const i32_gt_u = retasmFunc.i32_gt_u;
+export const i32_ge_u = retasmFunc.i32_ge_u;
+export const i32_store = retasmFunc.i32_store;
+export const i32_store8 = retasmFunc.i32_store8;
+export const i32_store16 = retasmFunc.i32_store16;
+export const i32_call = retasmFunc.i32_call;
+export const i32_call_indirect = retasmFunc.i32_call_indirect;
+export const i32_select = retasmFunc.i32_select;
+export const i64_add = retasmFunc.i64_add;
+export const i64_sub = retasmFunc.i64_sub;
+export const i64_mul = retasmFunc.i64_mul;
+export const i64_div_s = retasmFunc.i64_div_s;
+export const i64_div_u = retasmFunc.i64_div_u;
+export const i64_rem_s = retasmFunc.i64_rem_s;
+export const i64_rem_u = retasmFunc.i64_rem_u;
+export const i64_and = retasmFunc.i64_and;
+export const i64_or = retasmFunc.i64_or;
+export const i64_xor = retasmFunc.i64_xor;
+export const i64_shl = retasmFunc.i64_shl;
+export const i64_shr_u = retasmFunc.i64_shr_u;
+export const i64_shr_s = retasmFunc.i64_shr_s;
+export const i64_eq = retasmFunc.i64_eq;
+export const i64_ne = retasmFunc.i64_ne;
+export const i64_lt_s = retasmFunc.i64_lt_s;
+export const i64_le_s = retasmFunc.i64_le_s;
+export const i64_lt_u = retasmFunc.i64_lt_u;
+export const i64_le_u = retasmFunc.i64_le_u;
+export const i64_gt_s = retasmFunc.i64_gt_s;
+export const i64_ge_s = retasmFunc.i64_ge_s;
+export const i64_gt_u = retasmFunc.i64_gt_u;
+export const i64_ge_u = retasmFunc.i64_ge_u;
+export const i64_store = retasmFunc.i64_store;
+export const i64_store8 = retasmFunc.i64_store8;
+export const i64_store16 = retasmFunc.i64_store16;
+export const i64_store32 = retasmFunc.i64_store32;
+export const i64_call = retasmFunc.i64_call;
+export const i64_call_indirect = retasmFunc.i64_call_indirect;
+export const i64_select = retasmFunc.i64_select;
+export const f32_add = retasmFunc.f32_add;
+export const f32_sub = retasmFunc.f32_sub;
+export const f32_mul = retasmFunc.f32_mul;
+export const f32_div = retasmFunc.f32_div;
+export const f32_copysign = retasmFunc.f32_copysign;
+export const f32_eq = retasmFunc.f32_eq;
+export const f32_ne = retasmFunc.f32_ne;
+export const f32_lt = retasmFunc.f32_lt;
+export const f32_le = retasmFunc.f32_le;
+export const f32_gt = retasmFunc.f32_gt;
+export const f32_ge = retasmFunc.f32_ge;
+export const f32_min = retasmFunc.f32_min;
+export const f32_max = retasmFunc.f32_max;
+export const f32_store = retasmFunc.f32_store;
+export const f32_call = retasmFunc.f32_call;
+export const f32_call_indirect = retasmFunc.f32_call_indirect;
+export const f32_select = retasmFunc.f32_select;
+export const f64_add = retasmFunc.f64_add;
+export const f64_sub = retasmFunc.f64_sub;
+export const f64_mul = retasmFunc.f64_mul;
+export const f64_div = retasmFunc.f64_div;
+export const f64_copysign = retasmFunc.f64_copysign;
+export const f64_eq = retasmFunc.f64_eq;
+export const f64_ne = retasmFunc.f64_ne;
+export const f64_lt = retasmFunc.f64_lt;
+export const f64_le = retasmFunc.f64_le;
+export const f64_gt = retasmFunc.f64_gt;
+export const f64_ge = retasmFunc.f64_ge;
+export const f64_min = retasmFunc.f64_min;
+export const f64_max = retasmFunc.f64_max;
+export const f64_store = retasmFunc.f64_store;
+export const f64_call = retasmFunc.f64_call;
+export const f64_call_indirect = retasmFunc.f64_call_indirect;
+export const f64_select = retasmFunc.f64_select;
+export const br_if = retasmFunc.br_if;
+export const br_table = retasmFunc.br_table;
diff --git a/test/wasm2asm/loop.2asm.js b/test/wasm2js/loop.2asm.js
index f5de4b2b4..615a4d66c 100644
--- a/test/wasm2asm/loop.2asm.js
+++ b/test/wasm2js/loop.2asm.js
@@ -346,7 +346,7 @@ function asmFunc(global, env, buffer) {
  }
  
  function $14() {
-  var $0 = 0, $1_1 = 0, $6_1 = 0, $2_1 = 0, $7_1 = 0, $3_1 = 0, $8_1 = 0, $5_1 = 0, wasm2asm_i32$0 = 0;
+  var $0 = 0, $1_1 = 0, $6_1 = 0, $2_1 = 0, $7_1 = 0, $3_1 = 0, $8_1 = 0, $5_1 = 0, wasm2js_i32$0 = 0;
   $0 = 0;
   $1_1 = $0;
   loop_in : do {
@@ -356,7 +356,7 @@ function asmFunc(global, env, buffer) {
    } while (1);
    break loop_in;
   } while (1);
-  return wasm2asm_i32$0 | 0;
+  return wasm2js_i32$0 | 0;
  }
  
  function fx() {
@@ -617,3 +617,23 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const empty = retasmFunc.empty;
+export const singular = retasmFunc.singular;
+export const multi = retasmFunc.multi;
+export const nested = retasmFunc.nested;
+export const deep = retasmFunc.deep;
+export const as_unary_operand = retasmFunc.as_unary_operand;
+export const as_binary_operand = retasmFunc.as_binary_operand;
+export const as_test_operand = retasmFunc.as_test_operand;
+export const as_compare_operand = retasmFunc.as_compare_operand;
+export const break_bare = retasmFunc.break_bare;
+export const break_value = retasmFunc.break_value;
+export const break_repeated = retasmFunc.break_repeated;
+export const break_inner = retasmFunc.break_inner;
+export const cont_inner = retasmFunc.cont_inner;
+export const effects = retasmFunc.effects;
+export const while_ = retasmFunc.while_;
+export const for_ = retasmFunc.for_;
+export const nesting = retasmFunc.nesting;
diff --git a/test/wasm2asm/reinterpret.2asm.js b/test/wasm2js/reinterpret.2asm.js
index 97bc0d0f8..7928cb62e 100644
--- a/test/wasm2asm/reinterpret.2asm.js
+++ b/test/wasm2js/reinterpret.2asm.js
@@ -33,18 +33,18 @@ function asmFunc(global, env, buffer) {
  function $2($0, $0$hi) {
   $0 = $0 | 0;
   $0$hi = $0$hi | 0;
-  var i64toi32_i32$0 = 0, $3$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_f64$0 = 0.0;
+  var i64toi32_i32$0 = 0, $3$hi = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_f64$0 = 0.0;
   i64toi32_i32$0 = $0$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = $0;
-  HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_i32$1 = i64toi32_i32$0;
-  HEAP32[(wasm2asm_i32$0 + 4 | 0) >> 2] = wasm2asm_i32$1;
-  wasm2asm_i32$0 = 0;
-  wasm2asm_f64$0 = +HEAPF64[0 >> 3];
-  HEAPF64[wasm2asm_i32$0 >> 3] = wasm2asm_f64$0;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = $0;
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  HEAP32[(wasm2js_i32$0 + 4 | 0) >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = +HEAPF64[0 >> 3];
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
   i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
   $3$hi = i64toi32_i32$0;
   i64toi32_i32$0 = $0$hi;
@@ -58,3 +58,7 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const i32_roundtrip = retasmFunc.i32_roundtrip;
+export const i64_roundtrip = retasmFunc.i64_roundtrip;
diff --git a/test/wasm2asm/reinterpret.wast b/test/wasm2js/reinterpret.wast
index 816fb90a3..816fb90a3 100644
--- a/test/wasm2asm/reinterpret.wast
+++ b/test/wasm2js/reinterpret.wast
diff --git a/test/wasm2asm/select.2asm.js b/test/wasm2js/select.2asm.js
index 1fa01f6a1..cdbdd19aa 100644
--- a/test/wasm2asm/select.2asm.js
+++ b/test/wasm2js/select.2asm.js
@@ -25,8 +25,8 @@ function asmFunc(global, env, buffer) {
   lhs = lhs | 0;
   rhs = rhs | 0;
   cond = cond | 0;
-  var wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0;
-  return (wasm2asm_i32$0 = lhs, wasm2asm_i32$1 = rhs, wasm2asm_i32$2 = cond, wasm2asm_i32$2 ? wasm2asm_i32$0 : wasm2asm_i32$1) | 0;
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
+  return (wasm2js_i32$0 = lhs, wasm2js_i32$1 = rhs, wasm2js_i32$2 = cond, wasm2js_i32$2 ? wasm2js_i32$0 : wasm2js_i32$1) | 0;
  }
  
  function $1(lhs, lhs$hi, rhs, rhs$hi, cond) {
@@ -35,30 +35,30 @@ function asmFunc(global, env, buffer) {
   rhs = rhs | 0;
   rhs$hi = rhs$hi | 0;
   cond = cond | 0;
-  var i64toi32_i32$0 = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0;
+  var i64toi32_i32$0 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
   i64toi32_i32$0 = lhs$hi;
   i64toi32_i32$0 = rhs$hi;
   i64toi32_i32$0 = lhs$hi;
   i64toi32_i32$0 = rhs$hi;
   i64toi32_i32$0 = i64toi32_i32$0;
   i64toi32_i32$HIGH_BITS = i64toi32_i32$0;
-  return (wasm2asm_i32$0 = lhs, wasm2asm_i32$1 = rhs, wasm2asm_i32$2 = cond, wasm2asm_i32$2 ? wasm2asm_i32$0 : wasm2asm_i32$1) | 0;
+  return (wasm2js_i32$0 = lhs, wasm2js_i32$1 = rhs, wasm2js_i32$2 = cond, wasm2js_i32$2 ? wasm2js_i32$0 : wasm2js_i32$1) | 0;
  }
  
  function $2(lhs, rhs, cond) {
   lhs = Math_fround(lhs);
   rhs = Math_fround(rhs);
   cond = cond | 0;
-  var wasm2asm_f32$0 = Math_fround(0), wasm2asm_f32$1 = Math_fround(0), wasm2asm_i32$0 = 0;
-  return Math_fround((wasm2asm_f32$0 = lhs, wasm2asm_f32$1 = rhs, wasm2asm_i32$0 = cond, wasm2asm_i32$0 ? wasm2asm_f32$0 : wasm2asm_f32$1));
+  var wasm2js_f32$0 = Math_fround(0), wasm2js_f32$1 = Math_fround(0), wasm2js_i32$0 = 0;
+  return Math_fround((wasm2js_f32$0 = lhs, wasm2js_f32$1 = rhs, wasm2js_i32$0 = cond, wasm2js_i32$0 ? wasm2js_f32$0 : wasm2js_f32$1));
  }
  
  function $3(lhs, rhs, cond) {
   lhs = +lhs;
   rhs = +rhs;
   cond = cond | 0;
-  var wasm2asm_f64$0 = 0.0, wasm2asm_f64$1 = 0.0, wasm2asm_i32$0 = 0;
-  return +(wasm2asm_f64$0 = lhs, wasm2asm_f64$1 = rhs, wasm2asm_i32$0 = cond, wasm2asm_i32$0 ? wasm2asm_f64$0 : wasm2asm_f64$1);
+  var wasm2js_f64$0 = 0.0, wasm2js_f64$1 = 0.0, wasm2js_i32$0 = 0;
+  return +(wasm2js_f64$0 = lhs, wasm2js_f64$1 = rhs, wasm2js_i32$0 = cond, wasm2js_i32$0 ? wasm2js_f64$0 : wasm2js_f64$1);
  }
  
  function $4(cond) {
@@ -83,3 +83,11 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const select_i32 = retasmFunc.select_i32;
+export const select_i64 = retasmFunc.select_i64;
+export const select_f32 = retasmFunc.select_f32;
+export const select_f64 = retasmFunc.select_f64;
+export const select_trap_l = retasmFunc.select_trap_l;
+export const select_trap_r = retasmFunc.select_trap_r;
diff --git a/test/wasm2asm/set_local.2asm.js b/test/wasm2js/set_local.2asm.js
index add8cfee4..e6c6562fc 100644
--- a/test/wasm2asm/set_local.2asm.js
+++ b/test/wasm2js/set_local.2asm.js
@@ -116,3 +116,15 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const type_local_i32 = retasmFunc.type_local_i32;
+export const type_local_i64 = retasmFunc.type_local_i64;
+export const type_local_f32 = retasmFunc.type_local_f32;
+export const type_local_f64 = retasmFunc.type_local_f64;
+export const type_param_i32 = retasmFunc.type_param_i32;
+export const type_param_i64 = retasmFunc.type_param_i64;
+export const type_param_f32 = retasmFunc.type_param_f32;
+export const type_param_f64 = retasmFunc.type_param_f64;
+export const type_mixed = retasmFunc.type_mixed;
+export const write = retasmFunc.write;
diff --git a/test/wasm2asm/stack-modified.2asm.js b/test/wasm2js/stack-modified.2asm.js
index 18418d8b0..099eb1893 100644
--- a/test/wasm2asm/stack-modified.2asm.js
+++ b/test/wasm2js/stack-modified.2asm.js
@@ -387,3 +387,10 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const fac_expr = retasmFunc.fac_expr;
+export const fac_stack = retasmFunc.fac_stack;
+export const fac_stack_raw = retasmFunc.fac_stack_raw;
+export const fac_mixed = retasmFunc.fac_mixed;
+export const fac_mixed_raw = retasmFunc.fac_mixed_raw;
diff --git a/test/wasm2asm/stack-modified.wast b/test/wasm2js/stack-modified.wast
index 36565b80b..36565b80b 100644
--- a/test/wasm2asm/stack-modified.wast
+++ b/test/wasm2js/stack-modified.wast
diff --git a/test/wasm2asm/switch.2asm.js b/test/wasm2js/switch.2asm.js
index f31a940c1..f24849395 100644
--- a/test/wasm2asm/switch.2asm.js
+++ b/test/wasm2js/switch.2asm.js
@@ -193,3 +193,9 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const stmt = retasmFunc.stmt;
+export const expr = retasmFunc.expr;
+export const arg = retasmFunc.arg;
+export const corner = retasmFunc.corner;
diff --git a/test/wasm2asm/tee_local.2asm.js b/test/wasm2js/tee_local.2asm.js
index eee973f16..77bc0567f 100644
--- a/test/wasm2asm/tee_local.2asm.js
+++ b/test/wasm2js/tee_local.2asm.js
@@ -170,3 +170,16 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const type_local_i32 = retasmFunc.type_local_i32;
+export const type_local_i64 = retasmFunc.type_local_i64;
+export const type_local_f32 = retasmFunc.type_local_f32;
+export const type_local_f64 = retasmFunc.type_local_f64;
+export const type_param_i32 = retasmFunc.type_param_i32;
+export const type_param_i64 = retasmFunc.type_param_i64;
+export const type_param_f32 = retasmFunc.type_param_f32;
+export const type_param_f64 = retasmFunc.type_param_f64;
+export const type_mixed = retasmFunc.type_mixed;
+export const write = retasmFunc.write;
+export const result = retasmFunc.result;
diff --git a/test/wasm2asm/traps.2asm.js b/test/wasm2js/traps.2asm.js
index 73b8893cc..a869c6c74 100644
--- a/test/wasm2asm/traps.2asm.js
+++ b/test/wasm2js/traps.2asm.js
@@ -199,7 +199,7 @@ function asmFunc(global, env, buffer) {
   var$0$hi = var$0$hi | 0;
   var$1 = var$1 | 0;
   var$1$hi = var$1$hi | 0;
-  var i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$0 = 0, i64toi32_i32$5 = 0, var$2 = 0, var$3 = 0, var$4 = 0, var$5 = 0, var$5$hi = 0, var$6 = 0, var$6$hi = 0, i64toi32_i32$6 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, var$8$hi = 0, $46 = 0, $47 = 0, $48 = 0, $49 = 0, var$7$hi = 0, $50 = 0, $63$hi = 0, $65 = 0, $65$hi = 0, $66 = 0, $120$hi = 0, $129$hi = 0, $134$hi = 0, var$8 = 0, $140 = 0, $140$hi = 0, $142$hi = 0, $144 = 0, $144$hi = 0, $151 = 0, $151$hi = 0, $154$hi = 0, var$7 = 0, $165$hi = 0, wasm2asm_i32$0 = 0, wasm2asm_i32$1 = 0, wasm2asm_i32$2 = 0, wasm2asm_i32$3 = 0;
+  var i64toi32_i32$2 = 0, i64toi32_i32$3 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$0 = 0, i64toi32_i32$5 = 0, var$2 = 0, var$3 = 0, var$4 = 0, var$5 = 0, var$5$hi = 0, var$6 = 0, var$6$hi = 0, i64toi32_i32$6 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, var$8$hi = 0, $46 = 0, $47 = 0, $48 = 0, $49 = 0, var$7$hi = 0, $50 = 0, $63$hi = 0, $65 = 0, $65$hi = 0, $66 = 0, $120$hi = 0, $129$hi = 0, $134$hi = 0, var$8 = 0, $140 = 0, $140$hi = 0, $142$hi = 0, $144 = 0, $144$hi = 0, $151 = 0, $151$hi = 0, $154$hi = 0, var$7 = 0, $165$hi = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
   label$1 : {
    label$2 : {
     label$3 : {
@@ -267,12 +267,12 @@ function asmFunc(global, env, buffer) {
              i64toi32_i32$1 = 0;
              i64toi32_i32$2 = 1024;
              i64toi32_i32$1 = i64toi32_i32$1;
-             wasm2asm_i32$0 = i64toi32_i32$2;
-             wasm2asm_i32$1 = var$0 - Math_imul(var$2, var$3) | 0;
-             HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-             wasm2asm_i32$0 = i64toi32_i32$2;
-             wasm2asm_i32$1 = i64toi32_i32$1;
-             (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+             wasm2js_i32$0 = i64toi32_i32$2;
+             wasm2js_i32$1 = var$0 - Math_imul(var$2, var$3) | 0;
+             HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+             wasm2js_i32$0 = i64toi32_i32$2;
+             wasm2js_i32$1 = i64toi32_i32$1;
+             (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
              i64toi32_i32$1 = 0;
              i64toi32_i32$1 = i64toi32_i32$1;
              i64toi32_i32$2 = var$2;
@@ -330,12 +330,12 @@ function asmFunc(global, env, buffer) {
             $66 = i64toi32_i32$3 | i64toi32_i32$0 | 0;
             i64toi32_i32$3 = 1024;
             i64toi32_i32$1 = i64toi32_i32$1;
-            wasm2asm_i32$0 = i64toi32_i32$3;
-            wasm2asm_i32$1 = $66;
-            HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-            wasm2asm_i32$0 = i64toi32_i32$3;
-            wasm2asm_i32$1 = i64toi32_i32$1;
-            (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+            wasm2js_i32$0 = i64toi32_i32$3;
+            wasm2js_i32$1 = $66;
+            HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+            wasm2js_i32$0 = i64toi32_i32$3;
+            wasm2js_i32$1 = i64toi32_i32$1;
+            (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
             i64toi32_i32$1 = 0;
             i64toi32_i32$1 = i64toi32_i32$1;
             i64toi32_i32$3 = var$2 >>> ((__wasm_ctz_i32(var$3 | 0) | 0) & 31 | 0) | 0;
@@ -369,12 +369,12 @@ function asmFunc(global, env, buffer) {
         }
         i64toi32_i32$2 = 1024;
         i64toi32_i32$1 = i64toi32_i32$1;
-        wasm2asm_i32$0 = i64toi32_i32$2;
-        wasm2asm_i32$1 = $42;
-        HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-        wasm2asm_i32$0 = i64toi32_i32$2;
-        wasm2asm_i32$1 = i64toi32_i32$1;
-        (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+        wasm2js_i32$0 = i64toi32_i32$2;
+        wasm2js_i32$1 = $42;
+        HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+        wasm2js_i32$0 = i64toi32_i32$2;
+        wasm2js_i32$1 = i64toi32_i32$1;
+        (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
         i64toi32_i32$1 = 0;
         i64toi32_i32$1 = i64toi32_i32$1;
         i64toi32_i32$2 = var$4;
@@ -390,12 +390,12 @@ function asmFunc(global, env, buffer) {
       i64toi32_i32$2 = 0;
       i64toi32_i32$1 = 1024;
       i64toi32_i32$2 = i64toi32_i32$2;
-      wasm2asm_i32$0 = i64toi32_i32$1;
-      wasm2asm_i32$1 = var$4 & var$0 | 0;
-      HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-      wasm2asm_i32$0 = i64toi32_i32$1;
-      wasm2asm_i32$1 = i64toi32_i32$2;
-      (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+      wasm2js_i32$0 = i64toi32_i32$1;
+      wasm2js_i32$1 = var$4 & var$0 | 0;
+      HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+      wasm2js_i32$0 = i64toi32_i32$1;
+      wasm2js_i32$1 = i64toi32_i32$2;
+      (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
       if ((var$3 | 0) == (1 | 0)) break label$1;
       i64toi32_i32$2 = var$0$hi;
       i64toi32_i32$2 = 0;
@@ -601,12 +601,12 @@ function asmFunc(global, env, buffer) {
     i64toi32_i32$3 = var$5$hi;
     i64toi32_i32$2 = 1024;
     i64toi32_i32$3 = i64toi32_i32$3;
-    wasm2asm_i32$0 = i64toi32_i32$2;
-    wasm2asm_i32$1 = var$5;
-    HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-    wasm2asm_i32$0 = i64toi32_i32$2;
-    wasm2asm_i32$1 = i64toi32_i32$3;
-    (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+    wasm2js_i32$0 = i64toi32_i32$2;
+    wasm2js_i32$1 = var$5;
+    HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+    wasm2js_i32$0 = i64toi32_i32$2;
+    wasm2js_i32$1 = i64toi32_i32$3;
+    (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
     i64toi32_i32$3 = var$0$hi;
     i64toi32_i32$3 = i64toi32_i32$3;
     i64toi32_i32$5 = var$0;
@@ -635,12 +635,12 @@ function asmFunc(global, env, buffer) {
    i64toi32_i32$3 = var$0$hi;
    i64toi32_i32$5 = 1024;
    i64toi32_i32$3 = i64toi32_i32$3;
-   wasm2asm_i32$0 = i64toi32_i32$5;
-   wasm2asm_i32$1 = var$0;
-   HEAP32[wasm2asm_i32$0 >> 2] = wasm2asm_i32$1;
-   wasm2asm_i32$0 = i64toi32_i32$5;
-   wasm2asm_i32$1 = i64toi32_i32$3;
-   (wasm2asm_i32$2 = wasm2asm_i32$0, wasm2asm_i32$3 = wasm2asm_i32$1), ((HEAP8[(wasm2asm_i32$2 + 4 | 0) >> 0] = wasm2asm_i32$3 & 255 | 0, HEAP8[(wasm2asm_i32$2 + 5 | 0) >> 0] = (wasm2asm_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 6 | 0) >> 0] = (wasm2asm_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2asm_i32$2 + 7 | 0) >> 0] = (wasm2asm_i32$3 >>> 24 | 0) & 255 | 0;
+   wasm2js_i32$0 = i64toi32_i32$5;
+   wasm2js_i32$1 = var$0;
+   HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+   wasm2js_i32$0 = i64toi32_i32$5;
+   wasm2js_i32$1 = i64toi32_i32$3;
+   (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
    i64toi32_i32$3 = 0;
    var$0 = 0;
    var$0$hi = i64toi32_i32$3;
@@ -704,3 +704,9 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const no_dce_i32_div_s = retasmFunc.no_dce_i32_div_s;
+export const no_dce_i32_div_u = retasmFunc.no_dce_i32_div_u;
+export const no_dce_i64_div_s = retasmFunc.no_dce_i64_div_s;
+export const no_dce_i64_div_u = retasmFunc.no_dce_i64_div_u;
diff --git a/test/wasm2js/unaligned.2asm.js b/test/wasm2js/unaligned.2asm.js
new file mode 100644
index 000000000..61d49db7f
--- /dev/null
+++ b/test/wasm2js/unaligned.2asm.js
@@ -0,0 +1,121 @@
+function asmFunc(global, env, buffer) {
+ "use asm";
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+ var Math_imul = global.Math.imul;
+ var Math_fround = global.Math.fround;
+ var Math_abs = global.Math.abs;
+ var Math_clz32 = global.Math.clz32;
+ var Math_min = global.Math.min;
+ var Math_max = global.Math.max;
+ var Math_floor = global.Math.floor;
+ var Math_ceil = global.Math.ceil;
+ var Math_sqrt = global.Math.sqrt;
+ var abort = env.abort;
+ var nan = global.NaN;
+ var infinity = global.Infinity;
+ var i64toi32_i32$HIGH_BITS = 0;
+ function $0() {
+  var wasm2js_i32$0 = 0;
+  return (wasm2js_i32$0 = 0, HEAPU8[wasm2js_i32$0 >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 1 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 2 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 3 | 0) >> 0] | 0 | 0) << 24) | 0;
+ }
+ 
+ function $1() {
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2js_i32$0 = 0;
+  i64toi32_i32$2 = 0;
+  i64toi32_i32$0 = (wasm2js_i32$0 = i64toi32_i32$2, HEAPU8[wasm2js_i32$0 >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 1 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 2 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 3 | 0) >> 0] | 0 | 0) << 24);
+  i64toi32_i32$1 = (wasm2js_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2js_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
+  i64toi32_i32$1 = i64toi32_i32$1;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  i64toi32_i32$HIGH_BITS = i64toi32_i32$1;
+  return i64toi32_i32$0 | 0;
+ }
+ 
+ function $2() {
+  var wasm2js_i32$0 = 0;
+  return Math_fround((HEAP32[0] = (wasm2js_i32$0 = 0, HEAPU8[wasm2js_i32$0 >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 1 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 2 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 3 | 0) >> 0] | 0 | 0) << 24), HEAPF32[0]));
+ }
+ 
+ function $3() {
+  var i64toi32_i32$1 = 0, i64toi32_i32$2 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
+  i64toi32_i32$2 = 0;
+  i64toi32_i32$1 = (wasm2js_i32$0 = i64toi32_i32$2, HEAPU8[(wasm2js_i32$0 + 4 | 0) >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$0 + 5 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$0 + 6 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$0 + 7 | 0) >> 0] | 0 | 0) << 24);
+  i64toi32_i32$1 = i64toi32_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = (wasm2js_i32$2 = i64toi32_i32$2, HEAPU8[wasm2js_i32$2 >> 0] | 0 | 0 | (HEAPU8[(wasm2js_i32$2 + 1 | 0) >> 0] | 0 | 0) << 8 | (HEAPU8[(wasm2js_i32$2 + 2 | 0) >> 0] | 0 | 0) << 16 | (HEAPU8[(wasm2js_i32$2 + 3 | 0) >> 0] | 0 | 0) << 24);
+  HEAP32[wasm2js_i32$0 >> 2] = wasm2js_i32$1;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = i64toi32_i32$1;
+  HEAP32[(wasm2js_i32$0 + 4 | 0) >> 2] = wasm2js_i32$1;
+  return +(+HEAPF64[0 >> 3]);
+ }
+ 
+ function $4() {
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = 0;
+  (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[wasm2js_i32$2 >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 1 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 2 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 3 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
+ }
+ 
+ function $5() {
+  var i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
+  i64toi32_i32$1 = 0;
+  wasm2js_i32$0 = i64toi32_i32$1;
+  wasm2js_i32$1 = 0;
+  (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[wasm2js_i32$2 >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 1 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 2 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 3 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
+  wasm2js_i32$0 = i64toi32_i32$1;
+  wasm2js_i32$1 = 0;
+  (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
+ }
+ 
+ function $6() {
+  var wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_i32$1 = (HEAPF32[0] = Math_fround(0.0), HEAP32[0] | 0);
+  (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[wasm2js_i32$2 >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 1 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 2 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 3 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
+ }
+ 
+ function $7() {
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, wasm2js_i32$0 = 0, wasm2js_f64$0 = 0.0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0, wasm2js_i32$3 = 0;
+  wasm2js_i32$0 = 0;
+  wasm2js_f64$0 = 0.0;
+  HEAPF64[wasm2js_i32$0 >> 3] = wasm2js_f64$0;
+  i64toi32_i32$0 = HEAP32[(0 + 4 | 0) >> 2] | 0;
+  i64toi32_i32$1 = 0;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  wasm2js_i32$0 = i64toi32_i32$1;
+  wasm2js_i32$1 = HEAP32[0 >> 2] | 0;
+  (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[wasm2js_i32$2 >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 1 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 2 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 3 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
+  wasm2js_i32$0 = i64toi32_i32$1;
+  wasm2js_i32$1 = i64toi32_i32$0;
+  (wasm2js_i32$2 = wasm2js_i32$0, wasm2js_i32$3 = wasm2js_i32$1), ((HEAP8[(wasm2js_i32$2 + 4 | 0) >> 0] = wasm2js_i32$3 & 255 | 0, HEAP8[(wasm2js_i32$2 + 5 | 0) >> 0] = (wasm2js_i32$3 >>> 8 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 6 | 0) >> 0] = (wasm2js_i32$3 >>> 16 | 0) & 255 | 0), HEAP8[(wasm2js_i32$2 + 7 | 0) >> 0] = (wasm2js_i32$3 >>> 24 | 0) & 255 | 0;
+ }
+ 
+ return {
+  i32_load: $0, 
+  i64_load: $1, 
+  f32_load: $2, 
+  f64_load: $3, 
+  i32_store: $4, 
+  i64_store: $5, 
+  f32_store: $6, 
+  f64_store: $7
+ };
+}
+
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const i32_load = retasmFunc.i32_load;
+export const i64_load = retasmFunc.i64_load;
+export const f32_load = retasmFunc.f32_load;
+export const f64_load = retasmFunc.f64_load;
+export const i32_store = retasmFunc.i32_store;
+export const i64_store = retasmFunc.i64_store;
+export const f32_store = retasmFunc.f32_store;
+export const f64_store = retasmFunc.f64_store;
diff --git a/test/wasm2asm/unaligned.wast b/test/wasm2js/unaligned.wast
index 600d22459..600d22459 100644
--- a/test/wasm2asm/unaligned.wast
+++ b/test/wasm2js/unaligned.wast
diff --git a/test/wasm2asm/unary-ops.2asm.js b/test/wasm2js/unary-ops.2asm.js
index 254f6d810..6f57b676c 100644
--- a/test/wasm2asm/unary-ops.2asm.js
+++ b/test/wasm2js/unary-ops.2asm.js
@@ -271,3 +271,14 @@ function asmFunc(global, env, buffer) {
  };
 }
 
+const memasmFunc = new ArrayBuffer(65536);
+const retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc);
+export const i32_popcnt = retasmFunc.i32_popcnt;
+export const check_popcnt_i64 = retasmFunc.check_popcnt_i64;
+export const check_extend_ui32 = retasmFunc.check_extend_ui32;
+export const check_extend_si32 = retasmFunc.check_extend_si32;
+export const check_eqz_i64 = retasmFunc.check_eqz_i64;
+export const i32_clz = retasmFunc.i32_clz;
+export const i32_ctz = retasmFunc.i32_ctz;
+export const check_clz_i64 = retasmFunc.check_clz_i64;
+export const check_ctz_i64 = retasmFunc.check_ctz_i64;
diff --git a/test/wasm2asm/unary-ops.wast b/test/wasm2js/unary-ops.wast
index 821a8007e..821a8007e 100644
--- a/test/wasm2asm/unary-ops.wast
+++ b/test/wasm2js/unary-ops.wast
diff --git a/test/wasm2asm/wasm2asm.wast.asserts b/test/wasm2js/wasm2js.wast.asserts
index 353f563f2..353f563f2 100644
--- a/test/wasm2asm/wasm2asm.wast.asserts
+++ b/test/wasm2js/wasm2js.wast.asserts