From 50ad7544ec25e6a673b26bc3ef901d5795337f8c Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 09:43:10 -0700
Subject: [PATCH 01/42] go

---
 src/passes/AddFuzzImports.cpp | 53 +++++++++++++++++++++++++++++++++++
 src/passes/CMakeLists.txt     |  1 +
 src/passes/pass.cpp           |  3 ++
 src/passes/passes.h           |  1 +
 4 files changed, 58 insertions(+)
 create mode 100644 src/passes/AddFuzzImports.cpp

diff --git a/src/passes/AddFuzzImports.cpp b/src/passes/AddFuzzImports.cpp
new file mode 100644
index 00000000000..f24b25d32c2
--- /dev/null
+++ b/src/passes/AddFuzzImports.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2016 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//
+// Adds imports from a given module, using a random seed, for fuzzing purposes.
+// The module will be able to validly link and use parts of the given module.
+//
+// The seed is generated deterministically from the filename of the wasm to
+// import.
+//
+
+#include "pass.h"
+#include "wasm-builder.h"
+#include "wasm.h"
+
+namespace wasm {
+
+struct AddFuzzImports : public Pass {
+  // Makes various changes for fuzzing purposes, possibly effectful ones.
+  bool addsEffects() override { return true; }
+
+  void run(Module* module) override {
+    Name inputFile = getArgument(
+      "add-fuzz-imports",
+      "AddFuzzImports usage:  wasm-opt --add-fuzz-imports=IMPORTED_WASM");
+
+    Module input;
+    ModuleReader reader;
+    reader.read(inputFile, wasm);
+
+    addImports(*module, input);
+  }
+
+  void addImports(Module& wasm, Module& imported) {
+  }
+};
+
+Pass* createAddFuzzImportsPass() { return new AddFuzzImports(); }
+
+} // namespace wasm
diff --git a/src/passes/CMakeLists.txt b/src/passes/CMakeLists.txt
index e9818681a56..7b5cb72e191 100644
--- a/src/passes/CMakeLists.txt
+++ b/src/passes/CMakeLists.txt
@@ -18,6 +18,7 @@ set(passes_SOURCES
   string-utils.cpp
   test_passes.cpp
   AbstractTypeRefining.cpp
+  AddFuzzImports.cpp
   AlignmentLowering.cpp
   Asyncify.cpp
   AvoidReinterprets.cpp
diff --git a/src/passes/pass.cpp b/src/passes/pass.cpp
index 8c8ba8d33d0..e725578425a 100644
--- a/src/passes/pass.cpp
+++ b/src/passes/pass.cpp
@@ -585,6 +585,9 @@ void PassRegistry::registerPasses() {
   //   "lower-i64", "lowers i64 into pairs of i32s", createLowerInt64Pass);
 
   // Register passes used for internal testing. These don't show up in --help.
+  registerTestPass("add-fuzz-imports",
+                   "adds imports to a given module (for fuzzing)",
+                   createAddFuzzImportsPass);
   registerTestPass("catch-pop-fixup",
                    "fixup nested pops within catches",
                    createCatchPopFixupPass);
diff --git a/src/passes/passes.h b/src/passes/passes.h
index e8223e0bac8..4f2273bf4c9 100644
--- a/src/passes/passes.h
+++ b/src/passes/passes.h
@@ -197,6 +197,7 @@ Pass* createUnteePass();
 Pass* createVacuumPass();
 
 // Test passes:
+Pass* createAddFuzzImportsPass();
 Pass* createCatchPopFixupPass();
 
 } // namespace wasm

From 1063ccbf5b7b913e4a6f1bfd965692a4a23de696 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 09:46:01 -0700
Subject: [PATCH 02/42] go

---
 src/passes/AddFuzzImports.cpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/passes/AddFuzzImports.cpp b/src/passes/AddFuzzImports.cpp
index f24b25d32c2..d65d7b8d077 100644
--- a/src/passes/AddFuzzImports.cpp
+++ b/src/passes/AddFuzzImports.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 WebAssembly Community Group participants
+ * Copyright 2025 WebAssembly Community Group participants
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@
 //
 
 #include "pass.h"
+#include "support/hash.h"
 #include "wasm-builder.h"
 #include "wasm.h"
 
@@ -41,10 +42,14 @@ struct AddFuzzImports : public Pass {
     ModuleReader reader;
     reader.read(inputFile, wasm);
 
-    addImports(*module, input);
+    addImports(*module, input, getSeed(inputFile));
   }
 
-  void addImports(Module& wasm, Module& imported) {
+  size_t getSeed(Name name) {
+    return hash(name);
+  }
+
+  void addImports(Module& wasm, Module& imported, size_t seed) {
   }
 };
 

From 60477e67bd2f33077cc487c1075c5c1b0b00d90b Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 10:22:38 -0700
Subject: [PATCH 03/42] undo

---
 src/passes/AddFuzzImports.cpp | 58 -----------------------------------
 src/passes/CMakeLists.txt     |  1 -
 src/passes/pass.cpp           |  3 --
 src/passes/passes.h           |  1 -
 4 files changed, 63 deletions(-)
 delete mode 100644 src/passes/AddFuzzImports.cpp

diff --git a/src/passes/AddFuzzImports.cpp b/src/passes/AddFuzzImports.cpp
deleted file mode 100644
index d65d7b8d077..00000000000
--- a/src/passes/AddFuzzImports.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2025 WebAssembly Community Group participants
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-//
-// Adds imports from a given module, using a random seed, for fuzzing purposes.
-// The module will be able to validly link and use parts of the given module.
-//
-// The seed is generated deterministically from the filename of the wasm to
-// import.
-//
-
-#include "pass.h"
-#include "support/hash.h"
-#include "wasm-builder.h"
-#include "wasm.h"
-
-namespace wasm {
-
-struct AddFuzzImports : public Pass {
-  // Makes various changes for fuzzing purposes, possibly effectful ones.
-  bool addsEffects() override { return true; }
-
-  void run(Module* module) override {
-    Name inputFile = getArgument(
-      "add-fuzz-imports",
-      "AddFuzzImports usage:  wasm-opt --add-fuzz-imports=IMPORTED_WASM");
-
-    Module input;
-    ModuleReader reader;
-    reader.read(inputFile, wasm);
-
-    addImports(*module, input, getSeed(inputFile));
-  }
-
-  size_t getSeed(Name name) {
-    return hash(name);
-  }
-
-  void addImports(Module& wasm, Module& imported, size_t seed) {
-  }
-};
-
-Pass* createAddFuzzImportsPass() { return new AddFuzzImports(); }
-
-} // namespace wasm
diff --git a/src/passes/CMakeLists.txt b/src/passes/CMakeLists.txt
index 7b5cb72e191..e9818681a56 100644
--- a/src/passes/CMakeLists.txt
+++ b/src/passes/CMakeLists.txt
@@ -18,7 +18,6 @@ set(passes_SOURCES
   string-utils.cpp
   test_passes.cpp
   AbstractTypeRefining.cpp
-  AddFuzzImports.cpp
   AlignmentLowering.cpp
   Asyncify.cpp
   AvoidReinterprets.cpp
diff --git a/src/passes/pass.cpp b/src/passes/pass.cpp
index e725578425a..8c8ba8d33d0 100644
--- a/src/passes/pass.cpp
+++ b/src/passes/pass.cpp
@@ -585,9 +585,6 @@ void PassRegistry::registerPasses() {
   //   "lower-i64", "lowers i64 into pairs of i32s", createLowerInt64Pass);
 
   // Register passes used for internal testing. These don't show up in --help.
-  registerTestPass("add-fuzz-imports",
-                   "adds imports to a given module (for fuzzing)",
-                   createAddFuzzImportsPass);
   registerTestPass("catch-pop-fixup",
                    "fixup nested pops within catches",
                    createCatchPopFixupPass);
diff --git a/src/passes/passes.h b/src/passes/passes.h
index 4f2273bf4c9..e8223e0bac8 100644
--- a/src/passes/passes.h
+++ b/src/passes/passes.h
@@ -197,7 +197,6 @@ Pass* createUnteePass();
 Pass* createVacuumPass();
 
 // Test passes:
-Pass* createAddFuzzImportsPass();
 Pass* createCatchPopFixupPass();
 
 } // namespace wasm

From ed740fe154c36663b99607e13e3b955c8969e4f1 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 10:38:55 -0700
Subject: [PATCH 04/42] go

---
 src/tools/fuzzing.h           |  8 ++++++++
 src/tools/fuzzing/fuzzing.cpp | 30 ++++++++++++++++++++++++++++++
 src/tools/wasm-opt.cpp        | 12 ++++++++++++
 3 files changed, 50 insertions(+)

diff --git a/src/tools/fuzzing.h b/src/tools/fuzzing.h
index ed96370b5dc..76dfc7d67a6 100644
--- a/src/tools/fuzzing.h
+++ b/src/tools/fuzzing.h
@@ -132,6 +132,9 @@ class TranslateToFuzzReader {
   void setPreserveImportsAndExports(bool preserveImportsAndExports_) {
     preserveImportsAndExports = preserveImportsAndExports_;
   }
+  void setImportedModule(std::string importedModule_) {
+    importedModule = importedModule_;
+  }
 
   void build();
 
@@ -157,6 +160,9 @@ class TranslateToFuzzReader {
   // existing testcase (using initial-content).
   bool preserveImportsAndExports = false;
 
+  // An optional module to import from.
+  std::optional<std::string> importedModule;
+  
   // Whether we allow the fuzzer to add unreachable code when generating changes
   // to existing code. This is randomized during startup, but could be an option
   // like the above options eventually if we find that useful.
@@ -365,6 +371,8 @@ class TranslateToFuzzReader {
 
   void addHangLimitChecks(Function* func);
 
+  void useImportedModule();
+
   // Recombination and mutation
 
   // Recombination and mutation can replace a node with another node of the same
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index d77c0ac44b0..01093406baf 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -361,7 +361,12 @@ void TranslateToFuzzReader::build() {
   addImportLoggingSupport();
   addImportCallingSupport();
   addImportSleepSupport();
+
+  // First, modify initial functions. That includes removing imports. Then,
+  // use the imported module, which are function imports that we allow.
   modifyInitialFunctions();
+  useImportedModule();
+
   processFunctions();
   if (fuzzParams->HANG_LIMIT > 0) {
     addHangLimitSupport();
@@ -1158,6 +1163,31 @@ void TranslateToFuzzReader::addHashMemorySupport() {
   }
 }
 
+void TranslateToFuzzReader::useImportedModule() {
+  if (!importedModule) {
+    return;
+  }
+
+  Module imported;
+  ModuleReader().read(*importedModule, imported);
+
+  // Add some of the module's functions as imports, at a random rate.
+  auto rate = upTo(100);
+  for (auto& func : imported.functions) {
+    if (upTo(100) < rate) {
+      auto name = Names::getValidFunctionName(wasm, func->name);
+      // We can import it as its own type, or any (declared) supertype.
+      auto type = getSuperType(func->type);
+      wasm.addFunction(std::move(builder.makeFunction(name, type, {}));
+    }
+  }
+
+  // TODO: All other imports: globals, memories, tables, etc. We must, as we do
+  //       with functions, take care to run this *after* the removal of those
+  //       imports (as normally we remove them all, as the fuzzer harness will
+  //       not provide them, but an imported module is the exception).
+}
+
 TranslateToFuzzReader::FunctionCreationContext::FunctionCreationContext(
   TranslateToFuzzReader& parent, Function* func)
   : parent(parent), func(func) {
diff --git a/src/tools/wasm-opt.cpp b/src/tools/wasm-opt.cpp
index 5edd2a15b83..cb259081988 100644
--- a/src/tools/wasm-opt.cpp
+++ b/src/tools/wasm-opt.cpp
@@ -86,6 +86,7 @@ int main(int argc, const char* argv[]) {
   bool fuzzMemory = true;
   bool fuzzOOB = true;
   bool fuzzPreserveImportsAndExports = false;
+  std::string fuzzImport;
   std::string emitSpecWrapper;
   std::string emitWasm2CWrapper;
   std::string inputSourceMapFilename;
@@ -201,6 +202,14 @@ For more on how to optimize effectively, see
          [&](Options* o, const std::string& arguments) {
            fuzzPreserveImportsAndExports = true;
          })
+    .add("--fuzz-import",
+         "",
+         "a module to use as an import in -ttf mode",
+         WasmOptOption,
+         Options::Arguments::One,
+         [&](Options* o, const std::string& arguments) {
+           fuzzImport = arguments;
+         })
     .add("--emit-spec-wrapper",
          "-esw",
          "Emit a wasm spec interpreter wrapper file that can run the wasm with "
@@ -334,6 +343,9 @@ For more on how to optimize effectively, see
     reader.setAllowMemory(fuzzMemory);
     reader.setAllowOOB(fuzzOOB);
     reader.setPreserveImportsAndExports(fuzzPreserveImportsAndExports);
+    if (!fuzzImport.empty()) {
+      reader.setFuzzImport(fuzzImport);
+    }
     reader.build();
     if (options.passOptions.validate) {
       if (!WasmValidator().validate(wasm, options.passOptions)) {

From b17e3c878429185b5fb69b129c5eb3f827f1e4cd Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 10:45:44 -0700
Subject: [PATCH 05/42] work

---
 test/lit/fuzz-import.wast     |  17 +++++++++++++++++
 test/lit/fuzz-import.wast.ttf | Bin 0 -> 4023 bytes
 2 files changed, 17 insertions(+)
 create mode 100644 test/lit/fuzz-import.wast
 create mode 100644 test/lit/fuzz-import.wast.ttf

diff --git a/test/lit/fuzz-import.wast b/test/lit/fuzz-import.wast
new file mode 100644
index 00000000000..cc1818afa30
--- /dev/null
+++ b/test/lit/fuzz-import.wast
@@ -0,0 +1,17 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+
+;; Test the flag to import from a given module in fuzzer generation.
+
+;; Generate fuzz output using this wat as initial contents, and with the flag to
+;; preserve imports and exports. There should be no new imports or exports, and
+;; old ones must stay the same.
+
+;; RUN: wasm-opt %s.ttf --initial-fuzz=%s -all -ttf --fuzz-import=%s.import.wast \
+;; RUN:          -S -o - | filecheck %s
+
+(module
+  ;; This existing import will be made a non-import, but the ones from the
+  ;; imported module will be ok.
+  (import "a" "b" (func $import))
+)
+
diff --git a/test/lit/fuzz-import.wast.ttf b/test/lit/fuzz-import.wast.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..922d620d004e4070ddff5e69b942e5153ab4a22e
GIT binary patch
literal 4023
zcmV;o4@mI6@*xKBgm+@_^UF<kO~(fyQ5BjGiSowU%Hu@4F%m`nZ-n2P*Tu8YcB~GM
zQ>Qg-h><@a_V+EYBGOF?mfF-j78k*(j(8HD11C2SWzdy|PZh18xJJRi>%}yR+<BVc
zgqy7e)S(K%L>{W{w6u=;3m*!-fa#c{TDo4Ky@#2>H4Q_aafy1TU*0h^q^fe@Rw%4*
z=8AJY5n-WSj;<@PLf4gw?XlIA*3lBvPi6x2-f<A=ldg0kl0AJF5oO#N2KGHynR*J-
z8#=B)f%G4=ab-R|S9**=1NqDuihqgN8uFz896%R886)=)Ec&5Pp(L}#$D6o^VW`_b
zK>@-jTNS_S!WP^czW$-t*6Rs<Z;B+@a@s-;roV<h?LWXbqcj5YNqEN=FEYSe46Z&6
zI`)y7EfRV*Gasg0Cwp9f=*fY+%d^%hz<ASA)b~%#Oj9xb_u^kgh-FKmc9+wLZ=DN?
z^}}XZxO$}bN!Img?+*4Q%op!<cq4Cudtrn|UlM{=7oc6(E-O4Qhm{hx=d1${tEu0@
z_$O=n$Uvh#j3?bW;D9l|yylmOHmy4Rv>ujSOk2I^KQ~CJ*O_1H_MciKHeATJGl+`B
z8$}iMihi}K&gCPt{y9yGGdVe4VAaS$O3PzcTW5g1mJj35#G#)4nfDK20XKL1SnFkD
zY!c%+kxoVLEg22CcPIY|t)-~2L@5y{uW2A=-*Nb%Hx<z*W>U!h@*>!3`kM>w>doL>
z=@Wyyz2&*hasg|Ey-Dk1QELlV&Q=abI9B5OULFh1<)Y9K8hXwY%lr*+doaiHVN|L+
zu|FD=jP9BGe~1sPu%a&=-Yo$&4=xE;680Nlsb=)9^|KMfoXISfUeh|qtIk=)w_dr_
z;C18nu!&a2`4vuA3-2#6qj?+{=I*M!03>6~HLagG<|%7?7*0tAIdzk2aMq(>?^-Ao
zISeyqf-5)f%yKvQvCiZ;mE*!`I|J>RC$6z#_$0d6B5i-OAFFuW;46S{rBrEe?bf_u
z(f82s5tRvEF%C_ZAMq4pYK{Bd6R_`OlSwq=nbPAYX-@f(z`j!4pY8H-xRa6(?Z3B}
zd<6$XObS#P0BG*Dxe@wadIpW%tr{@qpN4+_)`hJW58D$|enr!)M2`qo7YO(s>+jUP
zSC(BRM>Np1<LHip=a5gKM-$TccIt}{qC5FOkBKziCcY8*<zt_*T*S+v8H#NaqN2!<
z5<}I1(<uFQW+*y80+1uziTCV@lo(lf`Bq6xTkp#RNXQ#pTAyJ;OBhXU!#3T=T@8;l
zLpn;AK*Y2sVgtQM^nD<;_%)#N3b5kP?VRFF>BMH2TbWg&h-X3@9no7l2T(rFzl<;K
z;igJ&rRl$-x3I2~n2KFLajt)m-iYTy^s8Fp8Y9)&l^%J+#B3(JZ5;eO+{d{FnZCWu
z;J!8eN~LfBy&wQbDQl$OkYo=IpyRr2;jKNvbMr@?l3_epE8GsV!vp$W@{C8vXx*6K
zk})bE;-n!2ruEn`sn&C)XUHuY4SFkFcJRuPu<3MXn6E^-wV`O_9^Ic~{BB+~={?JA
zp<ffH|9-?BdCj}Wa$1pqu!bA1IBIa4;#gLF_iJvtc3H{UTAJd&94PAg30jHP{c*?m
zvCsEgI@Ya8q&KolnDkBLzx)-kXD^$RrP7rJ*t6L6y<C5nV8uA4Qlt1-$?jy)yEYv5
zXH-=^Gd#wj%ZwrQji7afJZw1hzTQiQy<dlBa(;xduQoD8Ds$?pI;Tif75j-qzTw;2
z+=G{k#!eRySKI(>Lu$T*7Pn_SQEw&q+mlQ?tWtzVEGR}W11iYr;)YrQBaqZr0}!mI
zxil7R#s%Z2a^dHB0<dm%P}ImV%Aq=Zlrap?4Xtuy=!e5=+MOU<=QEK@;6R;LbGw&5
zCI2Gze$)yD3-SUT^#&NQmz?qYnVdtOEzcG@VtFc2$VXHvngjhJx&JHIs>t5%uMVZ0
z_Js0-X}2+k_1E-gtQ~q7&3naMqcU6Pg51}x!Q2$O$-2mka7J`w57RZx^z^~qX7b7%
zQVU}-M#?)rHEotb*xpJ|ZrJ{z;tqlducF0mK9FTAX~%qVs&y}_n{H~$0GN78jwFDv
zXp~Q|Ze}~^+JGF&hm&UJXrHnzHrLFsd4NAY3|OPER&u8pI-(-btCR});^0>I06kZ|
z^^U`3>%j84y9KEA{pSVoC7fS(I#^kSpeVTlajFL!!c;crviJn+-YGXOD`z#2Dyj}^
z8Q~K@ZKva#qz7ULZ{9(&<I?d(n~*1WRI1>|d!m)BuveG9C0@mw>CfD5GqVG_;T-CK
z{rh5=EG78j%2a2DM1}xcW_jp5l)Pdy0H)!Z`WB;>TkHOx^RIg#XA-(4u>)HZ@=&KR
zSGs!h9|d)zNRofDvcOE}+s_^C&I>7s)||RO1Y9uC7RuOvC*Bo@yk6U~(+YRCcf`H5
zlTmcK0DVyShGRzZ;#ALq!^kgb!8U8TwuGC(-cGP4lBAAfV#{rAcfW?^empn{(-5DZ
zwm?IJSn|b%dQ$Z&W3>kP9@pJF$f44jwaq8(V<ds#I)@^7vW|YG&>1EGOJs94X0=u<
zR?6uMHKl69)NwZ#Eh3v_UE^LXvnBXWNO^Pkj?W)<nYANWQ4Qrdc{f-@p={X<mM!3a
z>v=uTQgethK=08F#X5M_R4pg+4_SGos_^TTCpWhr3b&yWB3pz#4Uq5y*TflsuTQjS
zBBYtZPsf8QZTc?9oFt)sV{ystlu1qjdsyhc)XU(S&%&E1p*ASR*oEzwF?Q(pQ#Zo>
zY~Yv*la(b#U=<bg(#F8t2TlUO(&jaNT3Ww3w6P4Hxfzc8r~zof5`hCMf28vx^veUl
z37Y3c&VEkbFd`*8ehGf1pyU_Rb0)4i^L)cup;x!Qsxw>SE3aC!b1y>ho9&b`%OPSl
zC3}FOXINJ_Ph_v9c_vuQ1$~d67{2Jes++9gGOc5U_jBZ&WxF=>JN{j*Oc|;li~)F?
zy@gxjK}?~#Zl0vsDb;sBf;UD8`QU`4kZO|5CkQ;+ElN`7dyA;s9m#qHz>JWBP_zkg
zC|E#lCe;Mu(eipPr-ZQ$Y<uMK3;yh{Rje$t41nL^puaK?f=Muy<Cf+6E032Nx7&?!
zuTOgOXuco^3;NlR%fO4g=o;BFU4KoWvLIrS%!IS0ZUYJCEuo#=H$y+LI9WnrVC(st
zYNDL9wPU}zL6VJO*0}BJGARe!;pgMFmF~9?gHb&hEEti$=Io;a0BD}*o4|IY%(rL#
zd0}iqB8KUhMDah@!S9rL7x*rOCVIdN<3z<7IsWn6su7<(28*|he=xTs^MWV9;w=H5
zq^h9KMw+{hf9W|-wSK-Uw`rSTP75o@I~-~J)w8;J%_h*mWpBmuW&pmu6(6pnH)`%-
ziKV%++27A!z=X>EmkA}|Gcq~9`h$yYG4%G6{0jtNdfB_=O`(&&WL1X%(k>)i$EI`2
z6BLAe7pgZVk*sX-Ht>okW)x9w%Oo@p#o!H$^KweL;-~41ywJ!R%;_<_K?{jzTr7u2
z_k4*zR*_f=micGN3h`xx=qKmEm#+J7zB_a(Eg@;$GH!ZXR-YzYkef{ByciT<wC1dv
zz!D6y0nE-SSyf0wx{4_@S?GAiG!%|!;+YkFit6lIp<80jUfMh6oKbLf@n;lXbkB~c
zoRxPClVy{**ubK7=FDQZPqP`AB7^NZIc`X-VQ&tPoofomO&6T1uUX)}g>hemKUn{@
zz2D-(yRKCe!SS2MCRXJdCRdhmNR>*QUy-=BA*fZ_p^g#o*Xx%yTNBe$`OlU-aXxje
zD9F@;Ok)+4|2O)C9dJk~+Ypq5kVm2mb47ps-yTi0>n+?c=zn*LY%m2>wj=?g;4xZE
zeVj?ak!M6?A2-u`A^lBv=0h`^-WLoE7ks}DgabVN;W~ZK8C%UQ@flx%h<TIpyrbj{
z+VRTg{F)@ZL(*ea@rj4vy8YV&3?O5_!%PT#Qe!=IlUxb=eK{L`cvD!Rg9R=<o_p4p
zMuhI9%Hlh4*biDHLiTGtHRAIvy#5v6BwExEThq5#DA&v=wzF)gs{gs#EdyWKQsd(}
z$V#>)>$~Nc4w;UVh~2L%=40grFxRkjf&+?e(hQ>LhBI-4k_<hvPrVM2UtMAjz!fT~
zI2RJ6iuU9!X^ZgWUz_)6OUmmjit_91G)2<uz39ETi+8(cZEN!av|gJUdl3aL*0Z*I
znUUVWN>+^rcHEH<@a>);%HLNT=}h(dtsP;eJ-c1le+qzQdWO-sI|F(N%Y0K5ZByKN
z-l8V}I&+SFAVMG7Wp}pM8~`GF5+?slj6T%;54I@sFE^qCq&TocYm}O5*Ql(e@qRo{
z&?#)a5M65(dy79oShv(Z!{o%Kl_u_iwgpVyA~rmO#H#&oB^e7_50+0V*(03M;s2o(
z<(gFt6EKn1T3ouXmQbqOwLbbttOK+8ZIst`=vFY3??67s7)j7R>m&dur(hkJvcTKd
zF*p=s&5}gkl}I6dsahWmVFgix$#tf#KD3Tp5BAK#{2-ppr6)r29F_~roxih<*CzLc
zjei22ph1{rM!+6}1n#Q9jlR#;)aR|yb2G(W;C4lBO#M7A`@sN@bn{EvjH6J3ND7RG
zJ9ea!yYqM$V8@K0I7jvQCBn$_dP`=talWWY7N3k=P#6S`rLS^uCZeLi+LS^vx)TVU
zng!v@m%DJ#ddzlkg5aITD{iU>^|G;lc9I;sA@Z$exj{2?>w26a#k}q4cd`qUStxX^
zVtN6>W-$qcZ7Apx1we+MP{Xw>pqgoBVDZ?{&2}M5;t$D9^tD7XaMC?uqZg}FbOk7c
z`K86}+V`8bd0;T#NAK;4)hU>YHeicZ_OGA;a857BI!zzG27_}HotR%{(h~QwdeS(-
zCZC3Js;ml2FtRA`;#;Kml|?^T20NsvU!&92eIKatO%TdW1LC&N4S(S2d@CmgV^pi3
zbdS5f+FFNm3)&1N322sZaJMf02pk5YMXXPCy+KVykAaZ|V~Sj;l>uxvLfPux5!h?D
z3QU^No122J|CuTxMx<=G8PIZ7M=+Xoqn4?3WCaMa!!F)!G9H3i-2(nLtPMv6#~jaT
zeD_86?H2TDE5=UTq1qpUuxiH;tqfc1!o`)Ah@LGb(ecqOy~9G&%f)L4%p=G;?WL1o
z8T%s6_?He*{c!1Jm~~P9zj2Ym#RH{5%~J;H+8=Y*Ff*uyIn8uUp&z`qJF0yO+<Iez
dVjp7{N}WkIxSfPl-?SgY*0u&x6YD|B<7$w7?i&CA

literal 0
HcmV?d00001


From 26f018208c6cc00bc71000be5b2cc7dead0ec2b4 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 10:49:23 -0700
Subject: [PATCH 06/42] go

---
 src/tools/fuzzing/fuzzing.cpp | 21 ++++++++++++++-------
 src/tools/wasm-opt.cpp        |  2 +-
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index 01093406baf..d944f4651d9 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -24,6 +24,7 @@
 #include "ir/type-updating.h"
 #include "support/string.h"
 #include "tools/fuzzing/heap-types.h"
+#include "wasm-io.h"
 
 namespace wasm {
 
@@ -1171,15 +1172,21 @@ void TranslateToFuzzReader::useImportedModule() {
   Module imported;
   ModuleReader().read(*importedModule, imported);
 
-  // Add some of the module's functions as imports, at a random rate.
+  // Add some of the module's exported functions as imports, at a random rate.
   auto rate = upTo(100);
-  for (auto& func : imported.functions) {
-    if (upTo(100) < rate) {
-      auto name = Names::getValidFunctionName(wasm, func->name);
-      // We can import it as its own type, or any (declared) supertype.
-      auto type = getSuperType(func->type);
-      wasm.addFunction(std::move(builder.makeFunction(name, type, {}));
+  for (auto& exp : imported.exports) {
+    if (exp->kind != ExternalKind::Function || upTo(100) < rate) {
+      continue;
     }
+
+    auto* func = imported->getFunction(exp->value);
+    auto name = Names::getValidFunctionName(wasm, func->name);
+    // We can import it as its own type, or any (declared) supertype.
+    auto type = getSuperType(func->type);
+    auto func = builder.makeFunction(name, type, {});
+    func->module = "primary";
+    func->base = exportName;
+    wasm.addFunction(std::move(func));
   }
 
   // TODO: All other imports: globals, memories, tables, etc. We must, as we do
diff --git a/src/tools/wasm-opt.cpp b/src/tools/wasm-opt.cpp
index cb259081988..7735c5b2dcf 100644
--- a/src/tools/wasm-opt.cpp
+++ b/src/tools/wasm-opt.cpp
@@ -344,7 +344,7 @@ For more on how to optimize effectively, see
     reader.setAllowOOB(fuzzOOB);
     reader.setPreserveImportsAndExports(fuzzPreserveImportsAndExports);
     if (!fuzzImport.empty()) {
-      reader.setFuzzImport(fuzzImport);
+      reader.setImportedModule(fuzzImport);
     }
     reader.build();
     if (options.passOptions.validate) {

From 3e9f6407a07db28f926c05246aa43a4f63da8901 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 10:50:08 -0700
Subject: [PATCH 07/42] go

---
 src/tools/fuzzing/fuzzing.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index d944f4651d9..f8330d8a67c 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -1179,13 +1179,13 @@ void TranslateToFuzzReader::useImportedModule() {
       continue;
     }
 
-    auto* func = imported->getFunction(exp->value);
+    auto* func = imported.getFunction(exp->getInternalName());
     auto name = Names::getValidFunctionName(wasm, func->name);
     // We can import it as its own type, or any (declared) supertype.
     auto type = getSuperType(func->type);
     auto func = builder.makeFunction(name, type, {});
     func->module = "primary";
-    func->base = exportName;
+    func->base = exp->name;
     wasm.addFunction(std::move(func));
   }
 

From 60347f1ce03d380e4c1d9b9c1aecb26f7c127a4e Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 10:53:52 -0700
Subject: [PATCH 08/42] go

---
 src/tools/fuzzing/fuzzing.cpp         |   10 +-
 test/lit/fuzz-import.wast             | 1732 +++++++++++++++++++++++++
 test/lit/fuzz-import.wast.import.wast |   30 +
 3 files changed, 1767 insertions(+), 5 deletions(-)
 create mode 100644 test/lit/fuzz-import.wast.import.wast

diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index f8330d8a67c..1b352b6ae86 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -1179,14 +1179,14 @@ void TranslateToFuzzReader::useImportedModule() {
       continue;
     }
 
-    auto* func = imported.getFunction(exp->getInternalName());
+    auto* func = imported.getFunction(*exp->getInternalName());
     auto name = Names::getValidFunctionName(wasm, func->name);
     // We can import it as its own type, or any (declared) supertype.
     auto type = getSuperType(func->type);
-    auto func = builder.makeFunction(name, type, {});
-    func->module = "primary";
-    func->base = exp->name;
-    wasm.addFunction(std::move(func));
+    auto import = builder.makeFunction(name, type, {});
+    import->module = "primary";
+    import->base = exp->name;
+    wasm.addFunction(std::move(import));
   }
 
   // TODO: All other imports: globals, memories, tables, etc. We must, as we do
diff --git a/test/lit/fuzz-import.wast b/test/lit/fuzz-import.wast
index cc1818afa30..fce5d9b857e 100644
--- a/test/lit/fuzz-import.wast
+++ b/test/lit/fuzz-import.wast
@@ -15,3 +15,1735 @@
   (import "a" "b" (func $import))
 )
 
+;; CHECK:      (type $0 (func))
+
+;; CHECK:      (rec
+;; CHECK-NEXT:  (type $1 (sub (shared (struct (field i32) (field (ref null (shared array))) (field (mut f64)) (field v128) (field (ref null $generated_type$5))))))
+
+;; CHECK:       (type $2 (sub (array (ref null $6))))
+
+;; CHECK:       (type $generated_type$4 (sub $1 (shared (struct (field i32) (field (ref null (shared none))) (field (mut f64)) (field v128) (field (ref null $generated_type$5))))))
+
+;; CHECK:       (type $generated_type$5 (sub (shared (descriptor $5 (struct (field (ref (shared i31))) (field (ref $9)) (field (ref null $7)) (field (mut (ref null $7))) (field i16) (field i8))))))
+
+;; CHECK:       (type $5 (shared (describes $generated_type$5 (struct (field i8)))))
+
+;; CHECK:       (type $6 (sub $2 (array (ref null $6))))
+
+;; CHECK:       (type $7 (sub $generated_type$4 (shared (struct (field i32) (field (ref null (shared none))) (field (mut f64)) (field v128) (field (ref null $generated_type$5))))))
+
+;; CHECK:       (type $8 (array (ref $generated_type$4)))
+
+;; CHECK:       (type $9 (sub final $7 (shared (struct (field i32) (field (ref null (shared none))) (field (mut f64)) (field v128) (field (ref null (shared none)))))))
+
+;; CHECK:      (type $10 (struct))
+
+;; CHECK:      (type $generated_type$11 (sub $generated_type$4 (shared (struct (field i32) (field (ref null (shared none))) (field (mut f64)) (field v128) (field (ref $generated_type$5)) (field (ref (shared eq)))))))
+
+;; CHECK:      (type $12 (func (param i32)))
+
+;; CHECK:      (type $13 (array i8))
+
+;; CHECK:      (type $14 (func (param f64)))
+
+;; CHECK:      (type $15 (func (param f32)))
+
+;; CHECK:      (type $16 (shared (array i8)))
+
+;; CHECK:      (type $17 (func (param i32) (result funcref)))
+
+;; CHECK:      (type $18 (func (param i32 funcref)))
+
+;; CHECK:      (type $19 (func (param i64)))
+
+;; CHECK:      (type $20 (func (param v128)))
+
+;; CHECK:      (type $21 (func (param funcref i32)))
+
+;; CHECK:      (type $22 (func (param funcref) (result i32)))
+
+;; CHECK:      (type $23 (array (mut i16)))
+
+;; CHECK:      (type $24 (shared (struct)))
+
+;; CHECK:      (type $25 (func (result i64)))
+
+;; CHECK:      (type $26 (func (param i64 (ref null $0) f64 i32) (result (ref $5))))
+
+;; CHECK:      (type $27 (func (param stringref) (result (ref $0))))
+
+;; CHECK:      (import "fuzzing-support" "throw" (func $throw (type $12) (param i32)))
+
+;; CHECK:      (import "fuzzing-support" "table-get" (func $table-get (type $17) (param i32) (result funcref)))
+
+;; CHECK:      (import "fuzzing-support" "table-set" (func $table-set (type $18) (param i32 funcref)))
+
+;; CHECK:      (import "fuzzing-support" "log-i32" (func $log-i32 (type $12) (param i32)))
+
+;; CHECK:      (import "fuzzing-support" "log-i64" (func $log-i64 (type $19) (param i64)))
+
+;; CHECK:      (import "fuzzing-support" "log-f32" (func $log-f32 (type $15) (param f32)))
+
+;; CHECK:      (import "fuzzing-support" "log-f64" (func $log-f64 (type $14) (param f64)))
+
+;; CHECK:      (import "fuzzing-support" "log-v128" (func $log-v128 (type $20) (param v128)))
+
+;; CHECK:      (import "fuzzing-support" "call-ref" (func $call-ref (type $21) (param funcref i32)))
+
+;; CHECK:      (import "fuzzing-support" "call-ref-catch" (func $call-ref-catch (type $22) (param funcref) (result i32)))
+
+;; CHECK:      (global $global$ (mut stringref) (string.const "\c2\a3\c2\a3"))
+
+;; CHECK:      (global $global$_1 (mut arrayref) (array.new_fixed $13 0))
+
+;; CHECK:      (global $global$_2 (tuple (ref null $0) stringref) (tuple.make 2
+;; CHECK-NEXT:  (ref.func $import)
+;; CHECK-NEXT:  (string.const "")
+;; CHECK-NEXT: ))
+
+;; CHECK:      (global $global$_3 externref (ref.null noextern))
+
+;; CHECK:      (global $global$_4 (mut f64) (f64.const -nan:0xffffffffff34b))
+
+;; CHECK:      (global $global$_5 (ref null $9) (ref.null (shared none)))
+
+;; CHECK:      (global $global$_6 (ref $6) (array.new_default $6
+;; CHECK-NEXT:  (i32.const 73)
+;; CHECK-NEXT: ))
+
+;; CHECK:      (global $global$_7 funcref (ref.func $import))
+
+;; CHECK:      (global $global$_8 f32 (f32.const 2147483648))
+
+;; CHECK:      (global $global$_9 (ref $1) (struct.new $1
+;; CHECK-NEXT:  (i32.const 129)
+;; CHECK-NEXT:  (array.new_fixed $16 0)
+;; CHECK-NEXT:  (f64.const 91)
+;; CHECK-NEXT:  (v128.const i32x4 0x00820b8e 0xfee6ff27 0x92c3f9ff 0x209a6401)
+;; CHECK-NEXT:  (struct.new $generated_type$5
+;; CHECK-NEXT:   (ref.i31_shared
+;; CHECK-NEXT:    (i32.const -134217728)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (struct.new_default $9)
+;; CHECK-NEXT:   (struct.new $7
+;; CHECK-NEXT:    (i32.const -65535)
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:    (f64.const -48)
+;; CHECK-NEXT:    (v128.const i32x4 0xff841001 0xffbcffff 0x27210002 0x00800001)
+;; CHECK-NEXT:    (struct.new $generated_type$5
+;; CHECK-NEXT:     (ref.i31_shared
+;; CHECK-NEXT:      (i32.const -254)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (struct.new $9
+;; CHECK-NEXT:      (i32.const 1580403506)
+;; CHECK-NEXT:      (ref.null (shared none))
+;; CHECK-NEXT:      (f64.const -nan:0xfffffffffff92)
+;; CHECK-NEXT:      (v128.const i32x4 0x0900d9fa 0x807f06cb 0x091b9cff 0x2fff7f05)
+;; CHECK-NEXT:      (ref.null (shared none))
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (ref.null (shared none))
+;; CHECK-NEXT:     (ref.null (shared none))
+;; CHECK-NEXT:     (i32.const -9)
+;; CHECK-NEXT:     (i32.const -44)
+;; CHECK-NEXT:     (struct.new_default $5)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (struct.new $7
+;; CHECK-NEXT:    (i32.const -76)
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:    (f64.const -1073741824)
+;; CHECK-NEXT:    (v128.const i32x4 0x40f21cac 0x4f800000 0xff7fffff 0xff7fffff)
+;; CHECK-NEXT:    (struct.new $generated_type$5
+;; CHECK-NEXT:     (ref.i31_shared
+;; CHECK-NEXT:      (i32.const -1)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (struct.new_default $9)
+;; CHECK-NEXT:     (struct.new $7
+;; CHECK-NEXT:      (i32.const 1060664392)
+;; CHECK-NEXT:      (ref.null (shared none))
+;; CHECK-NEXT:      (f64.const 4294959958)
+;; CHECK-NEXT:      (v128.const i32x4 0x00000000 0x00000000 0xfffffff1 0xffffffff)
+;; CHECK-NEXT:      (struct.new $generated_type$5
+;; CHECK-NEXT:       (ref.i31_shared
+;; CHECK-NEXT:        (i32.const -536870912)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:       (struct.new $9
+;; CHECK-NEXT:        (i32.const -26867)
+;; CHECK-NEXT:        (ref.null (shared none))
+;; CHECK-NEXT:        (f64.const 68719476735.136)
+;; CHECK-NEXT:        (v128.const i32x4 0x3b029c01 0x025f00db 0x7f0c33ff 0x7f00ff0c)
+;; CHECK-NEXT:        (ref.null (shared none))
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:       (struct.new $7
+;; CHECK-NEXT:        (i32.const -59)
+;; CHECK-NEXT:        (ref.null (shared none))
+;; CHECK-NEXT:        (f64.const -2147483647.764)
+;; CHECK-NEXT:        (v128.const i32x4 0x00000000 0x80000000 0x0000006e 0x00000000)
+;; CHECK-NEXT:        (struct.new $generated_type$5
+;; CHECK-NEXT:         (ref.i31_shared
+;; CHECK-NEXT:          (i32.const 4194305)
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:         (struct.new $9
+;; CHECK-NEXT:          (i32.const -131072)
+;; CHECK-NEXT:          (ref.null (shared none))
+;; CHECK-NEXT:          (f64.const -nan:0xffffffffffff3)
+;; CHECK-NEXT:          (v128.const i32x4 0x80000001 0xffffffff 0xffff9250 0xffffffff)
+;; CHECK-NEXT:          (ref.null (shared none))
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:         (struct.new_default $7)
+;; CHECK-NEXT:         (ref.null (shared none))
+;; CHECK-NEXT:         (i32.const 511)
+;; CHECK-NEXT:         (i32.const 0)
+;; CHECK-NEXT:         (struct.new $5
+;; CHECK-NEXT:          (i32.const 256)
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:        )
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:       (ref.null (shared none))
+;; CHECK-NEXT:       (i32.const 4098)
+;; CHECK-NEXT:       (i32.const 206)
+;; CHECK-NEXT:       (struct.new $5
+;; CHECK-NEXT:        (i32.const -2147483648)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (struct.new $7
+;; CHECK-NEXT:      (i32.const -16384)
+;; CHECK-NEXT:      (ref.null (shared none))
+;; CHECK-NEXT:      (f64.const -512)
+;; CHECK-NEXT:      (v128.const i32x4 0xf47600db 0xffb5a67b 0xf267ffb1 0x8000ffc9)
+;; CHECK-NEXT:      (struct.new $generated_type$5
+;; CHECK-NEXT:       (ref.i31_shared
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:       (struct.new $9
+;; CHECK-NEXT:        (i32.const -16384)
+;; CHECK-NEXT:        (ref.null (shared none))
+;; CHECK-NEXT:        (f64.const -nan:0xfffffffffff8f)
+;; CHECK-NEXT:        (v128.const i32x4 0x00f000ed 0x0086e500 0x69004c00 0x78abc94a)
+;; CHECK-NEXT:        (ref.null (shared none))
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:       (struct.new $7
+;; CHECK-NEXT:        (i32.const -28307)
+;; CHECK-NEXT:        (ref.null (shared none))
+;; CHECK-NEXT:        (f64.const -0.138)
+;; CHECK-NEXT:        (v128.const i32x4 0x20000000 0x41600000 0xffffffdb 0xffffffff)
+;; CHECK-NEXT:        (struct.new $generated_type$5
+;; CHECK-NEXT:         (ref.i31_shared
+;; CHECK-NEXT:          (i32.const 2147483647)
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:         (struct.new $9
+;; CHECK-NEXT:          (i32.const -68)
+;; CHECK-NEXT:          (ref.null (shared none))
+;; CHECK-NEXT:          (f64.const 4067708437)
+;; CHECK-NEXT:          (v128.const i32x4 0xff000000 0x41efffff 0xff7126e9 0xc1cfffff)
+;; CHECK-NEXT:          (ref.null (shared none))
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:         (ref.null (shared none))
+;; CHECK-NEXT:         (struct.new_default $7)
+;; CHECK-NEXT:         (i32.const 33554433)
+;; CHECK-NEXT:         (i32.const 1)
+;; CHECK-NEXT:         (struct.new_default $5)
+;; CHECK-NEXT:        )
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:       (ref.null (shared none))
+;; CHECK-NEXT:       (i32.const 134217728)
+;; CHECK-NEXT:       (i32.const -98)
+;; CHECK-NEXT:       (struct.new_default $5)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (i32.const 65525)
+;; CHECK-NEXT:     (i32.const -2985)
+;; CHECK-NEXT:     (ref.null (shared none))
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (i32.const -563587298)
+;; CHECK-NEXT:   (i32.const -2932924)
+;; CHECK-NEXT:   (ref.null (shared none))
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: ))
+
+;; CHECK:      (global $global$_10 eqref (ref.null none))
+
+;; CHECK:      (global $global$_11 stringref (ref.null noextern))
+
+;; CHECK:      (global $global$_12 (ref $generated_type$4) (struct.new $generated_type$4
+;; CHECK-NEXT:  (i32.const 1073741824)
+;; CHECK-NEXT:  (ref.null (shared none))
+;; CHECK-NEXT:  (f64.const 4294967213)
+;; CHECK-NEXT:  (v128.const i32x4 0x0000008a 0x00400000 0x7fffffff 0xf2265e73)
+;; CHECK-NEXT:  (struct.new $generated_type$5
+;; CHECK-NEXT:   (ref.i31_shared
+;; CHECK-NEXT:    (i32.const -19423)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (struct.new_default $9)
+;; CHECK-NEXT:   (struct.new_default $7)
+;; CHECK-NEXT:   (struct.new_default $7)
+;; CHECK-NEXT:   (i32.const -128)
+;; CHECK-NEXT:   (i32.const -15)
+;; CHECK-NEXT:   (struct.new $5
+;; CHECK-NEXT:    (i32.const 32767)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: ))
+
+;; CHECK:      (global $global$_13 i64 (i64.const -32768))
+
+;; CHECK:      (global $global$_14 i32 (i32.const -7381244))
+
+;; CHECK:      (global $global$_15 (mut (tuple i32 (ref null $8) exnref f32 i64 stringref)) (tuple.make 6
+;; CHECK-NEXT:  (i32.const -13)
+;; CHECK-NEXT:  (ref.null none)
+;; CHECK-NEXT:  (ref.null noexn)
+;; CHECK-NEXT:  (f32.const 3402823466385288598117041e14)
+;; CHECK-NEXT:  (i64.const 45886)
+;; CHECK-NEXT:  (string.const "\ed\bd\88")
+;; CHECK-NEXT: ))
+
+;; CHECK:      (global $global$_16 i32 (global.get $global$_14))
+
+;; CHECK:      (global $global$_17 f32 (f32.const 9223372036854775808))
+
+;; CHECK:      (global $global$_18 (ref null $9) (global.get $global$_5))
+
+;; CHECK:      (global $global$_19 (ref $0) (ref.func $import))
+
+;; CHECK:      (global $global$_20 (ref $9) (struct.new $9
+;; CHECK-NEXT:  (i32.const 33375)
+;; CHECK-NEXT:  (ref.null (shared none))
+;; CHECK-NEXT:  (f64.const -nan:0xfffffffffffba)
+;; CHECK-NEXT:  (v128.const i32x4 0x00000003 0x00000000 0xc0000001 0xffffffff)
+;; CHECK-NEXT:  (ref.null (shared none))
+;; CHECK-NEXT: ))
+
+;; CHECK:      (global $global$_21 funcref (ref.func $import))
+
+;; CHECK:      (global $hangLimit (mut i32) (i32.const 100))
+
+;; CHECK:      (memory $0 i64 16 17 shared)
+
+;; CHECK:      (data $0 "\b5\08ANA\b2\ae")
+
+;; CHECK:      (data $1 (i64.const 0) "\c4I5\a6\8d>\c4\a1g\ff\a3\daf\90XX\14\b4n%\10\e2")
+
+;; CHECK:      (data $2 "\f8\ea\df\82sNi\14s")
+
+;; CHECK:      (data $3 (i64.const 22) "\d6=\8c\91\b9\c7\18\af@")
+
+;; CHECK:      (table $fuzzing_table 5 funcref)
+
+;; CHECK:      (table $exnref_table 8 exnref)
+
+;; CHECK:      (elem $elem$ (table $fuzzing_table) (i32.const 0) func $func_12 $func_12 $func_14)
+
+;; CHECK:      (elem declare func $func $import $log-f32 $log-i64)
+
+;; CHECK:      (tag $tag$ (type $14) (param f64))
+
+;; CHECK:      (export "table" (table $fuzzing_table))
+
+;; CHECK:      (export "func" (func $func))
+
+;; CHECK:      (export "func_12" (func $func_12))
+
+;; CHECK:      (export "func_13" (func $func_13))
+
+;; CHECK:      (export "func_14" (func $func_14))
+
+;; CHECK:      (export "func_14_invoker" (func $func_14_invoker))
+
+;; CHECK:      (export "func_16" (func $func_16))
+
+;; CHECK:      (func $import (type $0)
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (if
+;; CHECK-NEXT:    (i32.eqz
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (then
+;; CHECK-NEXT:     (global.set $hangLimit
+;; CHECK-NEXT:      (i32.const 100)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (unreachable)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (global.set $hangLimit
+;; CHECK-NEXT:    (i32.sub
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:     (i32.const 1)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (nop)
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $func (type $0)
+;; CHECK-NEXT:  (local $0 i32)
+;; CHECK-NEXT:  (local $1 (tuple i64 f64 v128 stringref funcref))
+;; CHECK-NEXT:  (local $2 (ref null $1))
+;; CHECK-NEXT:  (local $3 arrayref)
+;; CHECK-NEXT:  (local $4 f64)
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (if
+;; CHECK-NEXT:    (i32.eqz
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (then
+;; CHECK-NEXT:     (global.set $hangLimit
+;; CHECK-NEXT:      (i32.const 100)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (unreachable)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (global.set $hangLimit
+;; CHECK-NEXT:    (i32.sub
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:     (i32.const 1)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (block $label$0
+;; CHECK-NEXT:   (call $log-f32
+;; CHECK-NEXT:    (f32.const -68719476736)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $func_12 (type $12) (param $0 i32)
+;; CHECK-NEXT:  (local $1 (tuple i32 f32 f32 arrayref))
+;; CHECK-NEXT:  (local $2 (ref null $generated_type$4))
+;; CHECK-NEXT:  (local $3 f64)
+;; CHECK-NEXT:  (local $4 (ref $9))
+;; CHECK-NEXT:  (local $5 (ref struct))
+;; CHECK-NEXT:  (local $6 (ref $generated_type$11))
+;; CHECK-NEXT:  (local $7 (ref $5))
+;; CHECK-NEXT:  (local $8 v128)
+;; CHECK-NEXT:  (local $9 f64)
+;; CHECK-NEXT:  (local $10 (ref func))
+;; CHECK-NEXT:  (local $11 (ref $6))
+;; CHECK-NEXT:  (local $12 i64)
+;; CHECK-NEXT:  (local $13 structref)
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (if
+;; CHECK-NEXT:    (i32.eqz
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (then
+;; CHECK-NEXT:     (global.set $hangLimit
+;; CHECK-NEXT:      (i32.const 100)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (unreachable)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (global.set $hangLimit
+;; CHECK-NEXT:    (i32.sub
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:     (i32.const 1)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (local.set $7
+;; CHECK-NEXT:    (struct.new_default $5)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (block
+;; CHECK-NEXT:    (local.set $6
+;; CHECK-NEXT:     (struct.new $generated_type$11
+;; CHECK-NEXT:      (global.get $global$_16)
+;; CHECK-NEXT:      (ref.null (shared none))
+;; CHECK-NEXT:      (f64.const -nan:0xfffffffffffb8)
+;; CHECK-NEXT:      (local.get $8)
+;; CHECK-NEXT:      (struct.new $generated_type$5
+;; CHECK-NEXT:       (ref.i31_shared
+;; CHECK-NEXT:        (i32.const 127)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:       (global.get $global$_20)
+;; CHECK-NEXT:       (struct.new_default $7)
+;; CHECK-NEXT:       (struct.new_default $7)
+;; CHECK-NEXT:       (i32.const -2147483648)
+;; CHECK-NEXT:       (local.get $0)
+;; CHECK-NEXT:       (struct.new $5
+;; CHECK-NEXT:        (i32.const -536870913)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (struct.new_default $9)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (block
+;; CHECK-NEXT:     (local.set $4
+;; CHECK-NEXT:      (struct.new_default $9)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (block $label$0
+;; CHECK-NEXT:      (nop)
+;; CHECK-NEXT:      (nop)
+;; CHECK-NEXT:      (loop $label$1
+;; CHECK-NEXT:       (block
+;; CHECK-NEXT:        (if
+;; CHECK-NEXT:         (i32.eqz
+;; CHECK-NEXT:          (global.get $hangLimit)
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:         (then
+;; CHECK-NEXT:          (global.set $hangLimit
+;; CHECK-NEXT:           (i32.const 100)
+;; CHECK-NEXT:          )
+;; CHECK-NEXT:          (unreachable)
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:        )
+;; CHECK-NEXT:        (global.set $hangLimit
+;; CHECK-NEXT:         (i32.sub
+;; CHECK-NEXT:          (global.get $hangLimit)
+;; CHECK-NEXT:          (i32.const 1)
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:        )
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:       (block
+;; CHECK-NEXT:        (block $label$2
+;; CHECK-NEXT:         (atomic.fence)
+;; CHECK-NEXT:         (if
+;; CHECK-NEXT:          (i32.eqz
+;; CHECK-NEXT:           (ref.eq
+;; CHECK-NEXT:            (struct.new_default $10)
+;; CHECK-NEXT:            (struct.new_default $10)
+;; CHECK-NEXT:           )
+;; CHECK-NEXT:          )
+;; CHECK-NEXT:          (then
+;; CHECK-NEXT:           (block $label$3
+;; CHECK-NEXT:            (call $table-set
+;; CHECK-NEXT:             (local.tee $0
+;; CHECK-NEXT:              (local.tee $0
+;; CHECK-NEXT:               (tuple.extract 2 0
+;; CHECK-NEXT:                (tuple.make 2
+;; CHECK-NEXT:                 (i32.const 16777216)
+;; CHECK-NEXT:                 (ref.null noextern)
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (ref.func $func_12)
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:            (i32.atomic.store offset=22
+;; CHECK-NEXT:             (i64.and
+;; CHECK-NEXT:              (global.get $global$_13)
+;; CHECK-NEXT:              (i64.const 15)
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (i32.const -126)
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:           )
+;; CHECK-NEXT:          )
+;; CHECK-NEXT:          (else
+;; CHECK-NEXT:           (loop $label$4
+;; CHECK-NEXT:            (block
+;; CHECK-NEXT:             (if
+;; CHECK-NEXT:              (i32.eqz
+;; CHECK-NEXT:               (global.get $hangLimit)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:              (then
+;; CHECK-NEXT:               (global.set $hangLimit
+;; CHECK-NEXT:                (i32.const 100)
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:               (unreachable)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (global.set $hangLimit
+;; CHECK-NEXT:              (i32.sub
+;; CHECK-NEXT:               (global.get $hangLimit)
+;; CHECK-NEXT:               (i32.const 1)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:            (block
+;; CHECK-NEXT:             (block $label$5
+;; CHECK-NEXT:              (nop)
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (br_if $label$4
+;; CHECK-NEXT:              (string.measure_wtf16
+;; CHECK-NEXT:               (string.const "\ed\bd\88")
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (loop $label$6
+;; CHECK-NEXT:              (block
+;; CHECK-NEXT:               (if
+;; CHECK-NEXT:                (i32.eqz
+;; CHECK-NEXT:                 (global.get $hangLimit)
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (then
+;; CHECK-NEXT:                 (global.set $hangLimit
+;; CHECK-NEXT:                  (i32.const 100)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (unreachable)
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:               (global.set $hangLimit
+;; CHECK-NEXT:                (i32.sub
+;; CHECK-NEXT:                 (global.get $hangLimit)
+;; CHECK-NEXT:                 (i32.const 1)
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:              (block
+;; CHECK-NEXT:               (table.set $fuzzing_table
+;; CHECK-NEXT:                (i32.const 0)
+;; CHECK-NEXT:                (ref.null nofunc)
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:               (br_if $label$6
+;; CHECK-NEXT:                (loop $label$7 (result i32)
+;; CHECK-NEXT:                 (block
+;; CHECK-NEXT:                  (if
+;; CHECK-NEXT:                   (i32.eqz
+;; CHECK-NEXT:                    (global.get $hangLimit)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (then
+;; CHECK-NEXT:                    (global.set $hangLimit
+;; CHECK-NEXT:                     (i32.const 100)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (unreachable)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (global.set $hangLimit
+;; CHECK-NEXT:                   (i32.sub
+;; CHECK-NEXT:                    (global.get $hangLimit)
+;; CHECK-NEXT:                    (i32.const 1)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (block $label$8 (result i32)
+;; CHECK-NEXT:                  (br $label$0)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:               (atomic.fence)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:           )
+;; CHECK-NEXT:          )
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:        )
+;; CHECK-NEXT:        (br_if $label$1
+;; CHECK-NEXT:         (select
+;; CHECK-NEXT:          (if (result i32)
+;; CHECK-NEXT:           (i32.eqz
+;; CHECK-NEXT:            (local.get $0)
+;; CHECK-NEXT:           )
+;; CHECK-NEXT:           (then
+;; CHECK-NEXT:            (call $call-ref-catch
+;; CHECK-NEXT:             (if (result (ref func))
+;; CHECK-NEXT:              (ref.eq
+;; CHECK-NEXT:               (struct.new_default $10)
+;; CHECK-NEXT:               (struct.new_default $10)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:              (then
+;; CHECK-NEXT:               (block $label$31 (result (ref func))
+;; CHECK-NEXT:                (atomic.fence)
+;; CHECK-NEXT:                (ref.func $func)
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:              (else
+;; CHECK-NEXT:               (block $label$32 (result (ref func))
+;; CHECK-NEXT:                (loop $label$33
+;; CHECK-NEXT:                 (block
+;; CHECK-NEXT:                  (if
+;; CHECK-NEXT:                   (i32.eqz
+;; CHECK-NEXT:                    (global.get $hangLimit)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (then
+;; CHECK-NEXT:                    (global.set $hangLimit
+;; CHECK-NEXT:                     (i32.const 100)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (unreachable)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (global.set $hangLimit
+;; CHECK-NEXT:                   (i32.sub
+;; CHECK-NEXT:                    (global.get $hangLimit)
+;; CHECK-NEXT:                    (i32.const 1)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (block
+;; CHECK-NEXT:                  (nop)
+;; CHECK-NEXT:                  (br_if $label$33
+;; CHECK-NEXT:                   (i32.eqz
+;; CHECK-NEXT:                    (struct.get $9 0
+;; CHECK-NEXT:                     (global.get $global$_20)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (nop)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (local.tee $10
+;; CHECK-NEXT:                 (if (result (ref func))
+;; CHECK-NEXT:                  (i32.eqz
+;; CHECK-NEXT:                   (local.tee $0
+;; CHECK-NEXT:                    (i32.const 65444)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (then
+;; CHECK-NEXT:                   (br_table $label$0 $label$1 $label$0 $label$0 $label$1 $label$0 $label$0 $label$0
+;; CHECK-NEXT:                    (i32.shl
+;; CHECK-NEXT:                     (ref.eq
+;; CHECK-NEXT:                      (struct.new_default $10)
+;; CHECK-NEXT:                      (if (result (ref $2))
+;; CHECK-NEXT:                       (i32.eqz
+;; CHECK-NEXT:                        (i32.const 128)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (then
+;; CHECK-NEXT:                        (local.tee $11
+;; CHECK-NEXT:                         (global.get $global$_6)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (else
+;; CHECK-NEXT:                        (try_table (result (ref none)) (catch_all $label$0)
+;; CHECK-NEXT:                         (ref.as_non_null
+;; CHECK-NEXT:                          (ref.null none)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (block $label$34 (result i32)
+;; CHECK-NEXT:                      (call_ref $0
+;; CHECK-NEXT:                       (ref.func $import)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (br $label$1)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (else
+;; CHECK-NEXT:                   (if (result (ref $0))
+;; CHECK-NEXT:                    (i32.load16_u offset=3
+;; CHECK-NEXT:                     (i64.and
+;; CHECK-NEXT:                      (try_table (result i64) (catch_all $label$1)
+;; CHECK-NEXT:                       (i64.const -4398046511104)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (i64.const 15)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (then
+;; CHECK-NEXT:                     (block $label$35 (result (ref $0))
+;; CHECK-NEXT:                      (call $table-set
+;; CHECK-NEXT:                       (i8x16.extract_lane_s 10
+;; CHECK-NEXT:                        (block $label$36 (result v128)
+;; CHECK-NEXT:                         (nop)
+;; CHECK-NEXT:                         (br $label$0)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (ref.func $func_12)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (loop $label$37 (result (ref $0))
+;; CHECK-NEXT:                       (block
+;; CHECK-NEXT:                        (if
+;; CHECK-NEXT:                         (i32.eqz
+;; CHECK-NEXT:                          (global.get $hangLimit)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                         (then
+;; CHECK-NEXT:                          (global.set $hangLimit
+;; CHECK-NEXT:                           (i32.const 100)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                          (unreachable)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (global.set $hangLimit
+;; CHECK-NEXT:                         (i32.sub
+;; CHECK-NEXT:                          (global.get $hangLimit)
+;; CHECK-NEXT:                          (i32.const 1)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (block (result (ref $0))
+;; CHECK-NEXT:                        (block $label$38
+;; CHECK-NEXT:                         (struct.set $9 2
+;; CHECK-NEXT:                          (local.get $4)
+;; CHECK-NEXT:                          (f64.const -4398046511104)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                         (call $table-set
+;; CHECK-NEXT:                          (local.get $0)
+;; CHECK-NEXT:                          (call $table-get
+;; CHECK-NEXT:                           (loop $label$39 (result i32)
+;; CHECK-NEXT:                            (block
+;; CHECK-NEXT:                             (if
+;; CHECK-NEXT:                              (i32.eqz
+;; CHECK-NEXT:                               (global.get $hangLimit)
+;; CHECK-NEXT:                              )
+;; CHECK-NEXT:                              (then
+;; CHECK-NEXT:                               (global.set $hangLimit
+;; CHECK-NEXT:                                (i32.const 100)
+;; CHECK-NEXT:                               )
+;; CHECK-NEXT:                               (unreachable)
+;; CHECK-NEXT:                              )
+;; CHECK-NEXT:                             )
+;; CHECK-NEXT:                             (global.set $hangLimit
+;; CHECK-NEXT:                              (i32.sub
+;; CHECK-NEXT:                               (global.get $hangLimit)
+;; CHECK-NEXT:                               (i32.const 1)
+;; CHECK-NEXT:                              )
+;; CHECK-NEXT:                             )
+;; CHECK-NEXT:                            )
+;; CHECK-NEXT:                            (i32.const 10338)
+;; CHECK-NEXT:                           )
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (br_if $label$37
+;; CHECK-NEXT:                         (block $label$40 (result i32)
+;; CHECK-NEXT:                          (nop)
+;; CHECK-NEXT:                          (i32.atomic.load16_u offset=22
+;; CHECK-NEXT:                           (i64.and
+;; CHECK-NEXT:                            (i64.const -32768)
+;; CHECK-NEXT:                            (i64.const 15)
+;; CHECK-NEXT:                           )
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (ref.func $func)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (else
+;; CHECK-NEXT:                     (block $label$41
+;; CHECK-NEXT:                      (nop)
+;; CHECK-NEXT:                      (throw $tag$
+;; CHECK-NEXT:                       (f64.const -nan:0xffffffffffff2)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:           )
+;; CHECK-NEXT:           (else
+;; CHECK-NEXT:            (block $label$42 (result i32)
+;; CHECK-NEXT:             (call $log-v128
+;; CHECK-NEXT:              (v128.load offset=3 align=2
+;; CHECK-NEXT:               (i64.and
+;; CHECK-NEXT:                (loop $label$43 (result i64)
+;; CHECK-NEXT:                 (block
+;; CHECK-NEXT:                  (if
+;; CHECK-NEXT:                   (i32.eqz
+;; CHECK-NEXT:                    (global.get $hangLimit)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (then
+;; CHECK-NEXT:                    (global.set $hangLimit
+;; CHECK-NEXT:                     (i32.const 100)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (unreachable)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (global.set $hangLimit
+;; CHECK-NEXT:                   (i32.sub
+;; CHECK-NEXT:                    (global.get $hangLimit)
+;; CHECK-NEXT:                    (i32.const 1)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (block $label$44 (result i64)
+;; CHECK-NEXT:                  (drop
+;; CHECK-NEXT:                   (br_on_null $label$0
+;; CHECK-NEXT:                    (block (result (ref (exact $12)))
+;; CHECK-NEXT:                     (drop
+;; CHECK-NEXT:                      (br_on_null $label$0
+;; CHECK-NEXT:                       (block (result (ref string))
+;; CHECK-NEXT:                        (drop
+;; CHECK-NEXT:                         (br_on_null $label$1
+;; CHECK-NEXT:                          (ref.i31
+;; CHECK-NEXT:                           (i32.const 32767)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (string.const "\f0\90\8d\88\f0\90\8d\88\ed\bd\88")
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (ref.func $func_12)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (br $label$0)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (i64.const 15)
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (br $label$0)
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:           )
+;; CHECK-NEXT:          )
+;; CHECK-NEXT:          (select
+;; CHECK-NEXT:           (local.get $0)
+;; CHECK-NEXT:           (loop $label$46 (result i32)
+;; CHECK-NEXT:            (block
+;; CHECK-NEXT:             (if
+;; CHECK-NEXT:              (i32.eqz
+;; CHECK-NEXT:               (global.get $hangLimit)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:              (then
+;; CHECK-NEXT:               (global.set $hangLimit
+;; CHECK-NEXT:                (i32.const 100)
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:               (unreachable)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (global.set $hangLimit
+;; CHECK-NEXT:              (i32.sub
+;; CHECK-NEXT:               (global.get $hangLimit)
+;; CHECK-NEXT:               (i32.const 1)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:            (block (result i32)
+;; CHECK-NEXT:             (block $label$47
+;; CHECK-NEXT:              (struct.set $7 2
+;; CHECK-NEXT:               (struct.new $7
+;; CHECK-NEXT:                (i32.const -2)
+;; CHECK-NEXT:                (ref.null (shared none))
+;; CHECK-NEXT:                (f64.const -nan:0xfff81722f4d10)
+;; CHECK-NEXT:                (v128.const i32x4 0x00008001 0xffff8002 0xfe000001 0xffff9a40)
+;; CHECK-NEXT:                (ref.null (shared none))
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:               (tuple.extract 2 0
+;; CHECK-NEXT:                (tuple.make 2
+;; CHECK-NEXT:                 (f64.const 24109)
+;; CHECK-NEXT:                 (f32.const 3402823466385288598117041e14)
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:              (call $table-set
+;; CHECK-NEXT:               (local.get $0)
+;; CHECK-NEXT:               (ref.func $log-i64)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (br_if $label$46
+;; CHECK-NEXT:              (i32.eqz
+;; CHECK-NEXT:               (select
+;; CHECK-NEXT:                (ref.eq
+;; CHECK-NEXT:                 (if (result (ref $8))
+;; CHECK-NEXT:                  (i32.eqz
+;; CHECK-NEXT:                   (local.tee $0
+;; CHECK-NEXT:                    (global.get $global$_14)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (then
+;; CHECK-NEXT:                   (block $label$50 (result (ref $8))
+;; CHECK-NEXT:                    (array.new $8
+;; CHECK-NEXT:                     (local.get $6)
+;; CHECK-NEXT:                     (i32.const 1)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (else
+;; CHECK-NEXT:                   (block $label$51 (result (ref $8))
+;; CHECK-NEXT:                    (loop $label$52
+;; CHECK-NEXT:                     (block
+;; CHECK-NEXT:                      (if
+;; CHECK-NEXT:                       (i32.eqz
+;; CHECK-NEXT:                        (global.get $hangLimit)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (then
+;; CHECK-NEXT:                        (global.set $hangLimit
+;; CHECK-NEXT:                         (i32.const 100)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (unreachable)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (global.set $hangLimit
+;; CHECK-NEXT:                       (i32.sub
+;; CHECK-NEXT:                        (global.get $hangLimit)
+;; CHECK-NEXT:                        (i32.const 1)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (block
+;; CHECK-NEXT:                      (block $label$53
+;; CHECK-NEXT:                       (call $log-f64
+;; CHECK-NEXT:                        (f64x2.extract_lane 1
+;; CHECK-NEXT:                         (v128.const i32x4 0x46f46e00 0x746d6f5c 0xdf000000 0xdf000000)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (call $log-f32
+;; CHECK-NEXT:                        (f32.const 4398046511104)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (br_if $label$52
+;; CHECK-NEXT:                       (block $label$54 (result i32)
+;; CHECK-NEXT:                        (call $func)
+;; CHECK-NEXT:                        (local.tee $0
+;; CHECK-NEXT:                         (ref.eq
+;; CHECK-NEXT:                          (array.new_fixed $13 0)
+;; CHECK-NEXT:                          (local.get $13)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (call $throw
+;; CHECK-NEXT:                       (i32.const 0)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (array.new $8
+;; CHECK-NEXT:                     (struct.new_default $generated_type$4)
+;; CHECK-NEXT:                     (i32.const 13)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (struct.new_default $10)
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (local.tee $0
+;; CHECK-NEXT:                 (block $label$55 (result i32)
+;; CHECK-NEXT:                  (call $table-set
+;; CHECK-NEXT:                   (string.encode_wtf16_array
+;; CHECK-NEXT:                    (loop $label$56 (result (ref string))
+;; CHECK-NEXT:                     (block
+;; CHECK-NEXT:                      (if
+;; CHECK-NEXT:                       (i32.eqz
+;; CHECK-NEXT:                        (global.get $hangLimit)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (then
+;; CHECK-NEXT:                        (global.set $hangLimit
+;; CHECK-NEXT:                         (i32.const 100)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (unreachable)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (global.set $hangLimit
+;; CHECK-NEXT:                       (i32.sub
+;; CHECK-NEXT:                        (global.get $hangLimit)
+;; CHECK-NEXT:                        (i32.const 1)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (block (result (ref string))
+;; CHECK-NEXT:                      (block $label$57
+;; CHECK-NEXT:                       (call $log-i64
+;; CHECK-NEXT:                        (local.get $12)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (nop)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (br_if $label$56
+;; CHECK-NEXT:                       (i32.eqz
+;; CHECK-NEXT:                        (local.get $0)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (string.const "\e2\82\ac938\ed\a0\80")
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (array.new_default $23
+;; CHECK-NEXT:                     (i32.const 72)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (i32.atomic.load16_u offset=22
+;; CHECK-NEXT:                     (i64.and
+;; CHECK-NEXT:                      (global.get $global$_13)
+;; CHECK-NEXT:                      (i64.const 15)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (call $table-get
+;; CHECK-NEXT:                    (local.get $0)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (i32.atomic.rmw16.xchg_u offset=3
+;; CHECK-NEXT:                   (i64.and
+;; CHECK-NEXT:                    (i64.extend8_s
+;; CHECK-NEXT:                     (local.get $12)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (i64.const 15)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (i8x16.extract_lane_s 15
+;; CHECK-NEXT:                    (i32x4.splat
+;; CHECK-NEXT:                     (global.get $global$_14)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (struct.get $generated_type$11 0
+;; CHECK-NEXT:                 (struct.new $generated_type$11
+;; CHECK-NEXT:                  (i64.lt_s
+;; CHECK-NEXT:                   (global.get $global$_13)
+;; CHECK-NEXT:                   (local.get $12)
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (ref.null (shared none))
+;; CHECK-NEXT:                  (f64.const 3)
+;; CHECK-NEXT:                  (v128.load offset=3 align=8
+;; CHECK-NEXT:                   (i64.and
+;; CHECK-NEXT:                    (loop $label$48 (result i64)
+;; CHECK-NEXT:                     (block
+;; CHECK-NEXT:                      (if
+;; CHECK-NEXT:                       (i32.eqz
+;; CHECK-NEXT:                        (global.get $hangLimit)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (then
+;; CHECK-NEXT:                        (global.set $hangLimit
+;; CHECK-NEXT:                         (i32.const 100)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (unreachable)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (global.set $hangLimit
+;; CHECK-NEXT:                       (i32.sub
+;; CHECK-NEXT:                        (global.get $hangLimit)
+;; CHECK-NEXT:                        (i32.const 1)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (block (result i64)
+;; CHECK-NEXT:                      (block $label$49
+;; CHECK-NEXT:                       (try_table (catch_all $label$0)
+;; CHECK-NEXT:                        (atomic.fence)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (local.set $7
+;; CHECK-NEXT:                        (local.get $7)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (br_if $label$48
+;; CHECK-NEXT:                       (i32.eqz
+;; CHECK-NEXT:                        (i32.const -18605)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (local.tee $12
+;; CHECK-NEXT:                       (local.get $12)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (i64.const 15)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (struct.new $generated_type$5
+;; CHECK-NEXT:                   (ref.i31_shared
+;; CHECK-NEXT:                    (i32.const -569297635)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (struct.new_default $9)
+;; CHECK-NEXT:                   (struct.new_default $7)
+;; CHECK-NEXT:                   (ref.null (shared none))
+;; CHECK-NEXT:                   (local.get $0)
+;; CHECK-NEXT:                   (i32.const 20501)
+;; CHECK-NEXT:                   (ref.null (shared none))
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (struct.new_default $24)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (i16x8.extract_lane_u 2
+;; CHECK-NEXT:              (f64x2.splat
+;; CHECK-NEXT:               (f64.const -16383.795)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:           )
+;; CHECK-NEXT:           (local.get $0)
+;; CHECK-NEXT:          )
+;; CHECK-NEXT:          (string.measure_wtf16
+;; CHECK-NEXT:           (block $label$9 (result (ref string))
+;; CHECK-NEXT:            (try
+;; CHECK-NEXT:             (do
+;; CHECK-NEXT:              (drop
+;; CHECK-NEXT:               (br_on_cast $label$9 (ref string) (ref string)
+;; CHECK-NEXT:                (br_if $label$9
+;; CHECK-NEXT:                 (if (result (ref string))
+;; CHECK-NEXT:                  (i32.eqz
+;; CHECK-NEXT:                   (local.get $0)
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (then
+;; CHECK-NEXT:                   (block $label$10 (result (ref string))
+;; CHECK-NEXT:                    (i32.atomic.store offset=22
+;; CHECK-NEXT:                     (i64.and
+;; CHECK-NEXT:                      (i64.const 4294941230)
+;; CHECK-NEXT:                      (i64.const 15)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (local.tee $0
+;; CHECK-NEXT:                      (i32.const -65)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (br $label$1)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (else
+;; CHECK-NEXT:                   (block $label$11 (result (ref string))
+;; CHECK-NEXT:                    (nop)
+;; CHECK-NEXT:                    (select (result (ref string))
+;; CHECK-NEXT:                     (if (result (ref string))
+;; CHECK-NEXT:                      (i32.eqz
+;; CHECK-NEXT:                       (local.get $0)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (then
+;; CHECK-NEXT:                       (string.const "\c2\a3\c2\a3\c2\a3")
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (else
+;; CHECK-NEXT:                       (string.const "\c2\a3\ed\a0\80")
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (block $label$12 (result (ref string))
+;; CHECK-NEXT:                      (br $label$0)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (ref.is_null
+;; CHECK-NEXT:                      (struct.new_default $10)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (global.get $global$_14)
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (catch $tag$
+;; CHECK-NEXT:              (local.set $3
+;; CHECK-NEXT:               (pop f64)
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:              (loop $label$13
+;; CHECK-NEXT:               (block
+;; CHECK-NEXT:                (if
+;; CHECK-NEXT:                 (i32.eqz
+;; CHECK-NEXT:                  (global.get $hangLimit)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (then
+;; CHECK-NEXT:                  (global.set $hangLimit
+;; CHECK-NEXT:                   (i32.const 100)
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (unreachable)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (global.set $hangLimit
+;; CHECK-NEXT:                 (i32.sub
+;; CHECK-NEXT:                  (global.get $hangLimit)
+;; CHECK-NEXT:                  (i32.const 1)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:               (block
+;; CHECK-NEXT:                (drop
+;; CHECK-NEXT:                 (br_on_null $label$13
+;; CHECK-NEXT:                  (local.tee $4
+;; CHECK-NEXT:                   (struct.new $9
+;; CHECK-NEXT:                    (global.get $global$_16)
+;; CHECK-NEXT:                    (ref.null (shared none))
+;; CHECK-NEXT:                    (global.get $global$_4)
+;; CHECK-NEXT:                    (v128.const i32x4 0x0000fff6 0x8002fffe 0xff009b21 0x003fffc6)
+;; CHECK-NEXT:                    (ref.null (shared none))
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (br_if $label$13
+;; CHECK-NEXT:                 (i32.eqz
+;; CHECK-NEXT:                  (local.get $0)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (loop $label$14
+;; CHECK-NEXT:                 (block
+;; CHECK-NEXT:                  (if
+;; CHECK-NEXT:                   (i32.eqz
+;; CHECK-NEXT:                    (global.get $hangLimit)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (then
+;; CHECK-NEXT:                    (global.set $hangLimit
+;; CHECK-NEXT:                     (i32.const 100)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (unreachable)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (global.set $hangLimit
+;; CHECK-NEXT:                   (i32.sub
+;; CHECK-NEXT:                    (global.get $hangLimit)
+;; CHECK-NEXT:                    (i32.const 1)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (block
+;; CHECK-NEXT:                  (block $label$15
+;; CHECK-NEXT:                   (memory.fill
+;; CHECK-NEXT:                    (i64.and
+;; CHECK-NEXT:                     (i64.const -26772)
+;; CHECK-NEXT:                     (i64.const 15)
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (ref.eq
+;; CHECK-NEXT:                     (local.tee $5
+;; CHECK-NEXT:                      (struct.new_default $10)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (ref.as_non_null
+;; CHECK-NEXT:                      (ref.null none)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (i64.const -9223372036854775808)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (if
+;; CHECK-NEXT:                    (i32.eqz
+;; CHECK-NEXT:                     (memory.atomic.notify offset=22
+;; CHECK-NEXT:                      (i64.and
+;; CHECK-NEXT:                       (i64.const 9223372036854775807)
+;; CHECK-NEXT:                       (i64.const 15)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (block $label$16 (result i32)
+;; CHECK-NEXT:                       (nop)
+;; CHECK-NEXT:                       (local.get $0)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (then
+;; CHECK-NEXT:                     (br_if $label$1
+;; CHECK-NEXT:                      (i32.eqz
+;; CHECK-NEXT:                       (i32.const 8388608)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (br_if $label$14
+;; CHECK-NEXT:                   (call $call-ref-catch
+;; CHECK-NEXT:                    (global.get $global$_19)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (nop)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:             (catch_all
+;; CHECK-NEXT:              (struct.set $generated_type$11 2
+;; CHECK-NEXT:               (local.tee $6
+;; CHECK-NEXT:                (ref.cast (ref (shared none))
+;; CHECK-NEXT:                 (struct.new_default $1)
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:               (if (result f64)
+;; CHECK-NEXT:                (f32.ne
+;; CHECK-NEXT:                 (if (result f32)
+;; CHECK-NEXT:                  (struct.get_u $5 0
+;; CHECK-NEXT:                   (local.tee $7
+;; CHECK-NEXT:                    (ref.as_non_null
+;; CHECK-NEXT:                     (ref.null (shared none))
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (then
+;; CHECK-NEXT:                   (block $label$17 (result f32)
+;; CHECK-NEXT:                    (f32.const -nan:0x7fff84)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (else
+;; CHECK-NEXT:                   (block $label$18 (result f32)
+;; CHECK-NEXT:                    (if
+;; CHECK-NEXT:                     (i32.eqz
+;; CHECK-NEXT:                      (loop $label$19 (result i32)
+;; CHECK-NEXT:                       (block
+;; CHECK-NEXT:                        (if
+;; CHECK-NEXT:                         (i32.eqz
+;; CHECK-NEXT:                          (global.get $hangLimit)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                         (then
+;; CHECK-NEXT:                          (global.set $hangLimit
+;; CHECK-NEXT:                           (i32.const 100)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                          (unreachable)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (global.set $hangLimit
+;; CHECK-NEXT:                         (i32.sub
+;; CHECK-NEXT:                          (global.get $hangLimit)
+;; CHECK-NEXT:                          (i32.const 1)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (i32.const -129)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (then
+;; CHECK-NEXT:                      (loop $label$20
+;; CHECK-NEXT:                       (block
+;; CHECK-NEXT:                        (if
+;; CHECK-NEXT:                         (i32.eqz
+;; CHECK-NEXT:                          (global.get $hangLimit)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                         (then
+;; CHECK-NEXT:                          (global.set $hangLimit
+;; CHECK-NEXT:                           (i32.const 100)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                          (unreachable)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (global.set $hangLimit
+;; CHECK-NEXT:                         (i32.sub
+;; CHECK-NEXT:                          (global.get $hangLimit)
+;; CHECK-NEXT:                          (i32.const 1)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (block
+;; CHECK-NEXT:                        (nop)
+;; CHECK-NEXT:                        (br_if $label$20
+;; CHECK-NEXT:                         (local.get $0)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (nop)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (else
+;; CHECK-NEXT:                      (block $label$21
+;; CHECK-NEXT:                       (br_if $label$21
+;; CHECK-NEXT:                        (block $label$22 (result i32)
+;; CHECK-NEXT:                         (nop)
+;; CHECK-NEXT:                         (select
+;; CHECK-NEXT:                          (i32.const 268435456)
+;; CHECK-NEXT:                          (if (result i32)
+;; CHECK-NEXT:                           (i32.eqz
+;; CHECK-NEXT:                            (local.tee $0
+;; CHECK-NEXT:                             (local.get $0)
+;; CHECK-NEXT:                            )
+;; CHECK-NEXT:                           )
+;; CHECK-NEXT:                           (then
+;; CHECK-NEXT:                            (local.get $0)
+;; CHECK-NEXT:                           )
+;; CHECK-NEXT:                           (else
+;; CHECK-NEXT:                            (local.get $0)
+;; CHECK-NEXT:                           )
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                          (try_table (result i32) (catch_all $label$0)
+;; CHECK-NEXT:                           (i32.const 81)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (table.set $fuzzing_table
+;; CHECK-NEXT:                        (i32.const 1)
+;; CHECK-NEXT:                        (call $table-get
+;; CHECK-NEXT:                         (if (result i32)
+;; CHECK-NEXT:                          (i32.const -2048)
+;; CHECK-NEXT:                          (then
+;; CHECK-NEXT:                           (local.get $0)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                          (else
+;; CHECK-NEXT:                           (i32.const -77)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (br $label$1)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                 (f32.div
+;; CHECK-NEXT:                  (tuple.extract 2 0
+;; CHECK-NEXT:                   (tuple.make 2
+;; CHECK-NEXT:                    (f32.const 2147483648)
+;; CHECK-NEXT:                    (f64.const 18)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (loop $label$23 (result f32)
+;; CHECK-NEXT:                   (block
+;; CHECK-NEXT:                    (if
+;; CHECK-NEXT:                     (i32.eqz
+;; CHECK-NEXT:                      (global.get $hangLimit)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (then
+;; CHECK-NEXT:                      (global.set $hangLimit
+;; CHECK-NEXT:                       (i32.const 100)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (unreachable)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (global.set $hangLimit
+;; CHECK-NEXT:                     (i32.sub
+;; CHECK-NEXT:                      (global.get $hangLimit)
+;; CHECK-NEXT:                      (i32.const 1)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (block (result f32)
+;; CHECK-NEXT:                    (nop)
+;; CHECK-NEXT:                    (br_if $label$23
+;; CHECK-NEXT:                     (i16x8.extract_lane_u 0
+;; CHECK-NEXT:                      (local.get $8)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (f32.const -2147483648)
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (then
+;; CHECK-NEXT:                 (block $label$24 (result f64)
+;; CHECK-NEXT:                  (nop)
+;; CHECK-NEXT:                  (br $label$0)
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:                (else
+;; CHECK-NEXT:                 (block $label$25 (result f64)
+;; CHECK-NEXT:                  (call_ref $15
+;; CHECK-NEXT:                   (f32.const 2199023255552)
+;; CHECK-NEXT:                   (ref.func $log-f32)
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                  (loop $label$26 (result f64)
+;; CHECK-NEXT:                   (block
+;; CHECK-NEXT:                    (if
+;; CHECK-NEXT:                     (i32.eqz
+;; CHECK-NEXT:                      (global.get $hangLimit)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (then
+;; CHECK-NEXT:                      (global.set $hangLimit
+;; CHECK-NEXT:                       (i32.const 100)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (unreachable)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (global.set $hangLimit
+;; CHECK-NEXT:                     (i32.sub
+;; CHECK-NEXT:                      (global.get $hangLimit)
+;; CHECK-NEXT:                      (i32.const 1)
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                   (block (result f64)
+;; CHECK-NEXT:                    (block $label$27
+;; CHECK-NEXT:                     (call $log-f64
+;; CHECK-NEXT:                      (f64.convert_i32_u
+;; CHECK-NEXT:                       (if (result i32)
+;; CHECK-NEXT:                        (i32.eqz
+;; CHECK-NEXT:                         (i32.const -7)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (then
+;; CHECK-NEXT:                         (i32.const -110)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                        (else
+;; CHECK-NEXT:                         (i32.const -32162)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (br_if $label$26
+;; CHECK-NEXT:                     (i32.atomic.load16_u offset=22
+;; CHECK-NEXT:                      (i64.and
+;; CHECK-NEXT:                       (i64.const -6204899)
+;; CHECK-NEXT:                       (i64.const 15)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                    (try (result f64)
+;; CHECK-NEXT:                     (do
+;; CHECK-NEXT:                      (f64x2.extract_lane 1
+;; CHECK-NEXT:                       (block $label$28 (result v128)
+;; CHECK-NEXT:                        (local.get $8)
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                     (catch $tag$
+;; CHECK-NEXT:                      (local.set $9
+;; CHECK-NEXT:                       (pop f64)
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                      (if (result f64)
+;; CHECK-NEXT:                       (i32.load16_u offset=22
+;; CHECK-NEXT:                        (i64.and
+;; CHECK-NEXT:                         (i64.const -19)
+;; CHECK-NEXT:                         (i64.const 15)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (then
+;; CHECK-NEXT:                        (block $label$29 (result f64)
+;; CHECK-NEXT:                         (call $log-v128
+;; CHECK-NEXT:                          (local.tee $8
+;; CHECK-NEXT:                           (v128.const i32x4 0x0dfff881 0x012638f1 0x69d9009f 0x00e0012a)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                         (br $label$26)
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                       (else
+;; CHECK-NEXT:                        (block $label$30 (result f64)
+;; CHECK-NEXT:                         (call $table-set
+;; CHECK-NEXT:                          (local.get $0)
+;; CHECK-NEXT:                          (call $table-get
+;; CHECK-NEXT:                           (local.get $0)
+;; CHECK-NEXT:                          )
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                         (try_table (result f64) (catch $tag$ $label$25) (catch $tag$ $label$30) (catch $tag$ $label$30)
+;; CHECK-NEXT:                          (f64.const 1797693134862315708145274e284)
+;; CHECK-NEXT:                         )
+;; CHECK-NEXT:                        )
+;; CHECK-NEXT:                       )
+;; CHECK-NEXT:                      )
+;; CHECK-NEXT:                     )
+;; CHECK-NEXT:                    )
+;; CHECK-NEXT:                   )
+;; CHECK-NEXT:                  )
+;; CHECK-NEXT:                 )
+;; CHECK-NEXT:                )
+;; CHECK-NEXT:               )
+;; CHECK-NEXT:              )
+;; CHECK-NEXT:             )
+;; CHECK-NEXT:            )
+;; CHECK-NEXT:            (br $label$0)
+;; CHECK-NEXT:           )
+;; CHECK-NEXT:          )
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:        )
+;; CHECK-NEXT:        (v128.store offset=22 align=1
+;; CHECK-NEXT:         (i64.and
+;; CHECK-NEXT:          (local.get $12)
+;; CHECK-NEXT:          (i64.const 15)
+;; CHECK-NEXT:         )
+;; CHECK-NEXT:         (v128.const i32x4 0x20000001 0xffffffd5 0x00010000 0xfffffffd)
+;; CHECK-NEXT:        )
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $func_13 (type $25) (result i64)
+;; CHECK-NEXT:  (local $0 i64)
+;; CHECK-NEXT:  (local $1 i64)
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (if
+;; CHECK-NEXT:    (i32.eqz
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (then
+;; CHECK-NEXT:     (global.set $hangLimit
+;; CHECK-NEXT:      (i32.const 100)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (unreachable)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (global.set $hangLimit
+;; CHECK-NEXT:    (i32.sub
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:     (i32.const 1)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (i64.load16_u offset=22
+;; CHECK-NEXT:   (i64.load16_s offset=22 align=1
+;; CHECK-NEXT:    (i64.and
+;; CHECK-NEXT:     (local.tee $0
+;; CHECK-NEXT:      (local.get $1)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (i64.const 15)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $func_14 (type $26) (param $0 i64) (param $1 (ref null $0)) (param $2 f64) (param $3 i32) (result (ref $5))
+;; CHECK-NEXT:  (local $4 f32)
+;; CHECK-NEXT:  (local $5 (ref struct))
+;; CHECK-NEXT:  (local $6 (ref array))
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (if
+;; CHECK-NEXT:    (i32.eqz
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (then
+;; CHECK-NEXT:     (global.set $hangLimit
+;; CHECK-NEXT:      (i32.const 100)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (unreachable)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (global.set $hangLimit
+;; CHECK-NEXT:    (i32.sub
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:     (i32.const 1)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (return
+;; CHECK-NEXT:   (struct.new $5
+;; CHECK-NEXT:    (local.get $3)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $func_14_invoker (type $0)
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (if
+;; CHECK-NEXT:    (i32.eqz
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (then
+;; CHECK-NEXT:     (global.set $hangLimit
+;; CHECK-NEXT:      (i32.const 100)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (unreachable)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (global.set $hangLimit
+;; CHECK-NEXT:    (i32.sub
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:     (i32.const 1)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (drop
+;; CHECK-NEXT:    (call $func_14
+;; CHECK-NEXT:     (i64.const -47)
+;; CHECK-NEXT:     (ref.null nofunc)
+;; CHECK-NEXT:     (f64.const 1.1754943508222875e-38)
+;; CHECK-NEXT:     (i32.const -87)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (drop
+;; CHECK-NEXT:    (call $func_14
+;; CHECK-NEXT:     (i64.const -19)
+;; CHECK-NEXT:     (ref.func $import)
+;; CHECK-NEXT:     (f64.const -2147483648)
+;; CHECK-NEXT:     (i32.const -124)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (drop
+;; CHECK-NEXT:    (call $func_14
+;; CHECK-NEXT:     (i64.const 51497)
+;; CHECK-NEXT:     (ref.func $func)
+;; CHECK-NEXT:     (f64.const -nan:0xfffffffffffbc)
+;; CHECK-NEXT:     (i32.const -128)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $func_16 (type $27) (param $0 stringref) (result (ref $0))
+;; CHECK-NEXT:  (block
+;; CHECK-NEXT:   (if
+;; CHECK-NEXT:    (i32.eqz
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (then
+;; CHECK-NEXT:     (global.set $hangLimit
+;; CHECK-NEXT:      (i32.const 100)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (unreachable)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (global.set $hangLimit
+;; CHECK-NEXT:    (i32.sub
+;; CHECK-NEXT:     (global.get $hangLimit)
+;; CHECK-NEXT:     (i32.const 1)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (block $label$0
+;; CHECK-NEXT:   (return
+;; CHECK-NEXT:    (ref.as_non_null
+;; CHECK-NEXT:     (ref.null nofunc)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
diff --git a/test/lit/fuzz-import.wast.import.wast b/test/lit/fuzz-import.wast.import.wast
new file mode 100644
index 00000000000..7a9a940c773
--- /dev/null
+++ b/test/lit/fuzz-import.wast.import.wast
@@ -0,0 +1,30 @@
+;; Use lots of functions so we end up importing at least some.
+(module
+  (func $a (param i32)
+  )
+  (func $a1 (param i32)
+  )
+  (func $a2 (param i32)
+  )
+  (func $a3 (param i32)
+  )
+  (func $a4 (param i32)
+  )
+
+  (func $b (result i32)
+   (i32.const 0)
+  )
+  (func $b1 (result i32)
+   (i32.const 1)
+  )
+  (func $b2 (result i32)
+   (i32.const 2)
+  )
+  (func $b3 (result i32)
+   (i32.const 3)
+  )
+  (func $b4 (result i32)
+   (i32.const 4)
+  )
+)
+

From 811f664808b836bc705e7f54159c3197b0296e4f Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 10:56:21 -0700
Subject: [PATCH 09/42] go

---
 src/tools/fuzzing/fuzzing.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index 1b352b6ae86..58a4a1a4981 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -1165,9 +1165,11 @@ void TranslateToFuzzReader::addHashMemorySupport() {
 }
 
 void TranslateToFuzzReader::useImportedModule() {
+std::cout << "a1\n";
   if (!importedModule) {
     return;
   }
+std::cout << "a2\n";
 
   Module imported;
   ModuleReader().read(*importedModule, imported);
@@ -1175,9 +1177,11 @@ void TranslateToFuzzReader::useImportedModule() {
   // Add some of the module's exported functions as imports, at a random rate.
   auto rate = upTo(100);
   for (auto& exp : imported.exports) {
+std::cout << "a3\n";
     if (exp->kind != ExternalKind::Function || upTo(100) < rate) {
       continue;
     }
+std::cout << "a4\n";
 
     auto* func = imported.getFunction(*exp->getInternalName());
     auto name = Names::getValidFunctionName(wasm, func->name);

From 0aa09653c4616fd8b9af6d23d2ba1b4bb9dd9834 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 10:59:04 -0700
Subject: [PATCH 10/42] go

---
 test/lit/fuzz-import.wast.import.wast | 29 ++++++++++++++++++---------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/test/lit/fuzz-import.wast.import.wast b/test/lit/fuzz-import.wast.import.wast
index 7a9a940c773..51b3aed876b 100644
--- a/test/lit/fuzz-import.wast.import.wast
+++ b/test/lit/fuzz-import.wast.import.wast
@@ -1,30 +1,39 @@
 ;; Use lots of functions so we end up importing at least some.
 (module
-  (func $a (param i32)
+  (global $g i32 (i32.const 42))
+
+  ;; A non-function export should not cause problems.
+  (export "e-g" (global $g))
+
+  (func $a (export "e-a") (param i32)
   )
-  (func $a1 (param i32)
+  (func $a1 (export "e-a1") (param i32)
   )
-  (func $a2 (param i32)
+  (func $a2 (export "e-a2") (param i32)
   )
-  (func $a3 (param i32)
+  (func $a3 (export "e-a3") (param i32)
   )
-  (func $a4 (param i32)
+  (func $a4 (export "e-a4") (param i32)
   )
 
-  (func $b (result i32)
+  (func $b (export "e-b") (result i32)
    (i32.const 0)
   )
-  (func $b1 (result i32)
+  (func $b1 (export "e-b1") (result i32)
    (i32.const 1)
   )
-  (func $b2 (result i32)
+  (func $b2 (export "e-b2") (result i32)
    (i32.const 2)
   )
-  (func $b3 (result i32)
+  (func $b3 (export "e-b3") (result i32)
    (i32.const 3)
   )
-  (func $b4 (result i32)
+  (func $b4 (export "e-b4") (result i32)
    (i32.const 4)
   )
+
+  ;; A non-exported function should not cause a problem.
+  (func $c
+  )
 )
 

From 4b2b432a3f18bf0d72fa2c0452ec8706bf87dfc6 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 11:14:45 -0700
Subject: [PATCH 11/42] go

---
 src/tools/fuzzing/fuzzing.cpp         |    6 +-
 test/lit/fuzz-import.wast             | 1738 +------------------------
 test/lit/fuzz-import.wast.import.wast | 1033 ++++++++++++++-
 3 files changed, 1010 insertions(+), 1767 deletions(-)

diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index 58a4a1a4981..ab621a54ca1 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -1165,11 +1165,9 @@ void TranslateToFuzzReader::addHashMemorySupport() {
 }
 
 void TranslateToFuzzReader::useImportedModule() {
-std::cout << "a1\n";
   if (!importedModule) {
     return;
   }
-std::cout << "a2\n";
 
   Module imported;
   ModuleReader().read(*importedModule, imported);
@@ -1177,11 +1175,9 @@ std::cout << "a2\n";
   // Add some of the module's exported functions as imports, at a random rate.
   auto rate = upTo(100);
   for (auto& exp : imported.exports) {
-std::cout << "a3\n";
-    if (exp->kind != ExternalKind::Function || upTo(100) < rate) {
+    if (exp->kind != ExternalKind::Function || upTo(100) > rate) {
       continue;
     }
-std::cout << "a4\n";
 
     auto* func = imported.getFunction(*exp->getInternalName());
     auto name = Names::getValidFunctionName(wasm, func->name);
diff --git a/test/lit/fuzz-import.wast b/test/lit/fuzz-import.wast
index fce5d9b857e..7974c921311 100644
--- a/test/lit/fuzz-import.wast
+++ b/test/lit/fuzz-import.wast
@@ -1,5 +1,3 @@
-;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
-
 ;; Test the flag to import from a given module in fuzzer generation.
 
 ;; Generate fuzz output using this wat as initial contents, and with the flag to
@@ -15,1735 +13,9 @@
   (import "a" "b" (func $import))
 )
 
-;; CHECK:      (type $0 (func))
-
-;; CHECK:      (rec
-;; CHECK-NEXT:  (type $1 (sub (shared (struct (field i32) (field (ref null (shared array))) (field (mut f64)) (field v128) (field (ref null $generated_type$5))))))
-
-;; CHECK:       (type $2 (sub (array (ref null $6))))
-
-;; CHECK:       (type $generated_type$4 (sub $1 (shared (struct (field i32) (field (ref null (shared none))) (field (mut f64)) (field v128) (field (ref null $generated_type$5))))))
-
-;; CHECK:       (type $generated_type$5 (sub (shared (descriptor $5 (struct (field (ref (shared i31))) (field (ref $9)) (field (ref null $7)) (field (mut (ref null $7))) (field i16) (field i8))))))
-
-;; CHECK:       (type $5 (shared (describes $generated_type$5 (struct (field i8)))))
-
-;; CHECK:       (type $6 (sub $2 (array (ref null $6))))
-
-;; CHECK:       (type $7 (sub $generated_type$4 (shared (struct (field i32) (field (ref null (shared none))) (field (mut f64)) (field v128) (field (ref null $generated_type$5))))))
-
-;; CHECK:       (type $8 (array (ref $generated_type$4)))
-
-;; CHECK:       (type $9 (sub final $7 (shared (struct (field i32) (field (ref null (shared none))) (field (mut f64)) (field v128) (field (ref null (shared none)))))))
-
-;; CHECK:      (type $10 (struct))
-
-;; CHECK:      (type $generated_type$11 (sub $generated_type$4 (shared (struct (field i32) (field (ref null (shared none))) (field (mut f64)) (field v128) (field (ref $generated_type$5)) (field (ref (shared eq)))))))
-
-;; CHECK:      (type $12 (func (param i32)))
-
-;; CHECK:      (type $13 (array i8))
-
-;; CHECK:      (type $14 (func (param f64)))
-
-;; CHECK:      (type $15 (func (param f32)))
-
-;; CHECK:      (type $16 (shared (array i8)))
-
-;; CHECK:      (type $17 (func (param i32) (result funcref)))
-
-;; CHECK:      (type $18 (func (param i32 funcref)))
-
-;; CHECK:      (type $19 (func (param i64)))
-
-;; CHECK:      (type $20 (func (param v128)))
-
-;; CHECK:      (type $21 (func (param funcref i32)))
-
-;; CHECK:      (type $22 (func (param funcref) (result i32)))
-
-;; CHECK:      (type $23 (array (mut i16)))
-
-;; CHECK:      (type $24 (shared (struct)))
-
-;; CHECK:      (type $25 (func (result i64)))
-
-;; CHECK:      (type $26 (func (param i64 (ref null $0) f64 i32) (result (ref $5))))
-
-;; CHECK:      (type $27 (func (param stringref) (result (ref $0))))
-
-;; CHECK:      (import "fuzzing-support" "throw" (func $throw (type $12) (param i32)))
-
-;; CHECK:      (import "fuzzing-support" "table-get" (func $table-get (type $17) (param i32) (result funcref)))
-
-;; CHECK:      (import "fuzzing-support" "table-set" (func $table-set (type $18) (param i32 funcref)))
-
-;; CHECK:      (import "fuzzing-support" "log-i32" (func $log-i32 (type $12) (param i32)))
-
-;; CHECK:      (import "fuzzing-support" "log-i64" (func $log-i64 (type $19) (param i64)))
-
-;; CHECK:      (import "fuzzing-support" "log-f32" (func $log-f32 (type $15) (param f32)))
-
-;; CHECK:      (import "fuzzing-support" "log-f64" (func $log-f64 (type $14) (param f64)))
-
-;; CHECK:      (import "fuzzing-support" "log-v128" (func $log-v128 (type $20) (param v128)))
-
-;; CHECK:      (import "fuzzing-support" "call-ref" (func $call-ref (type $21) (param funcref i32)))
-
-;; CHECK:      (import "fuzzing-support" "call-ref-catch" (func $call-ref-catch (type $22) (param funcref) (result i32)))
-
-;; CHECK:      (global $global$ (mut stringref) (string.const "\c2\a3\c2\a3"))
-
-;; CHECK:      (global $global$_1 (mut arrayref) (array.new_fixed $13 0))
-
-;; CHECK:      (global $global$_2 (tuple (ref null $0) stringref) (tuple.make 2
-;; CHECK-NEXT:  (ref.func $import)
-;; CHECK-NEXT:  (string.const "")
-;; CHECK-NEXT: ))
-
-;; CHECK:      (global $global$_3 externref (ref.null noextern))
-
-;; CHECK:      (global $global$_4 (mut f64) (f64.const -nan:0xffffffffff34b))
-
-;; CHECK:      (global $global$_5 (ref null $9) (ref.null (shared none)))
-
-;; CHECK:      (global $global$_6 (ref $6) (array.new_default $6
-;; CHECK-NEXT:  (i32.const 73)
-;; CHECK-NEXT: ))
-
-;; CHECK:      (global $global$_7 funcref (ref.func $import))
-
-;; CHECK:      (global $global$_8 f32 (f32.const 2147483648))
-
-;; CHECK:      (global $global$_9 (ref $1) (struct.new $1
-;; CHECK-NEXT:  (i32.const 129)
-;; CHECK-NEXT:  (array.new_fixed $16 0)
-;; CHECK-NEXT:  (f64.const 91)
-;; CHECK-NEXT:  (v128.const i32x4 0x00820b8e 0xfee6ff27 0x92c3f9ff 0x209a6401)
-;; CHECK-NEXT:  (struct.new $generated_type$5
-;; CHECK-NEXT:   (ref.i31_shared
-;; CHECK-NEXT:    (i32.const -134217728)
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (struct.new_default $9)
-;; CHECK-NEXT:   (struct.new $7
-;; CHECK-NEXT:    (i32.const -65535)
-;; CHECK-NEXT:    (ref.null (shared none))
-;; CHECK-NEXT:    (f64.const -48)
-;; CHECK-NEXT:    (v128.const i32x4 0xff841001 0xffbcffff 0x27210002 0x00800001)
-;; CHECK-NEXT:    (struct.new $generated_type$5
-;; CHECK-NEXT:     (ref.i31_shared
-;; CHECK-NEXT:      (i32.const -254)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (struct.new $9
-;; CHECK-NEXT:      (i32.const 1580403506)
-;; CHECK-NEXT:      (ref.null (shared none))
-;; CHECK-NEXT:      (f64.const -nan:0xfffffffffff92)
-;; CHECK-NEXT:      (v128.const i32x4 0x0900d9fa 0x807f06cb 0x091b9cff 0x2fff7f05)
-;; CHECK-NEXT:      (ref.null (shared none))
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (ref.null (shared none))
-;; CHECK-NEXT:     (ref.null (shared none))
-;; CHECK-NEXT:     (i32.const -9)
-;; CHECK-NEXT:     (i32.const -44)
-;; CHECK-NEXT:     (struct.new_default $5)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (struct.new $7
-;; CHECK-NEXT:    (i32.const -76)
-;; CHECK-NEXT:    (ref.null (shared none))
-;; CHECK-NEXT:    (f64.const -1073741824)
-;; CHECK-NEXT:    (v128.const i32x4 0x40f21cac 0x4f800000 0xff7fffff 0xff7fffff)
-;; CHECK-NEXT:    (struct.new $generated_type$5
-;; CHECK-NEXT:     (ref.i31_shared
-;; CHECK-NEXT:      (i32.const -1)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (struct.new_default $9)
-;; CHECK-NEXT:     (struct.new $7
-;; CHECK-NEXT:      (i32.const 1060664392)
-;; CHECK-NEXT:      (ref.null (shared none))
-;; CHECK-NEXT:      (f64.const 4294959958)
-;; CHECK-NEXT:      (v128.const i32x4 0x00000000 0x00000000 0xfffffff1 0xffffffff)
-;; CHECK-NEXT:      (struct.new $generated_type$5
-;; CHECK-NEXT:       (ref.i31_shared
-;; CHECK-NEXT:        (i32.const -536870912)
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:       (struct.new $9
-;; CHECK-NEXT:        (i32.const -26867)
-;; CHECK-NEXT:        (ref.null (shared none))
-;; CHECK-NEXT:        (f64.const 68719476735.136)
-;; CHECK-NEXT:        (v128.const i32x4 0x3b029c01 0x025f00db 0x7f0c33ff 0x7f00ff0c)
-;; CHECK-NEXT:        (ref.null (shared none))
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:       (struct.new $7
-;; CHECK-NEXT:        (i32.const -59)
-;; CHECK-NEXT:        (ref.null (shared none))
-;; CHECK-NEXT:        (f64.const -2147483647.764)
-;; CHECK-NEXT:        (v128.const i32x4 0x00000000 0x80000000 0x0000006e 0x00000000)
-;; CHECK-NEXT:        (struct.new $generated_type$5
-;; CHECK-NEXT:         (ref.i31_shared
-;; CHECK-NEXT:          (i32.const 4194305)
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:         (struct.new $9
-;; CHECK-NEXT:          (i32.const -131072)
-;; CHECK-NEXT:          (ref.null (shared none))
-;; CHECK-NEXT:          (f64.const -nan:0xffffffffffff3)
-;; CHECK-NEXT:          (v128.const i32x4 0x80000001 0xffffffff 0xffff9250 0xffffffff)
-;; CHECK-NEXT:          (ref.null (shared none))
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:         (struct.new_default $7)
-;; CHECK-NEXT:         (ref.null (shared none))
-;; CHECK-NEXT:         (i32.const 511)
-;; CHECK-NEXT:         (i32.const 0)
-;; CHECK-NEXT:         (struct.new $5
-;; CHECK-NEXT:          (i32.const 256)
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:        )
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:       (ref.null (shared none))
-;; CHECK-NEXT:       (i32.const 4098)
-;; CHECK-NEXT:       (i32.const 206)
-;; CHECK-NEXT:       (struct.new $5
-;; CHECK-NEXT:        (i32.const -2147483648)
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:      )
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (struct.new $7
-;; CHECK-NEXT:      (i32.const -16384)
-;; CHECK-NEXT:      (ref.null (shared none))
-;; CHECK-NEXT:      (f64.const -512)
-;; CHECK-NEXT:      (v128.const i32x4 0xf47600db 0xffb5a67b 0xf267ffb1 0x8000ffc9)
-;; CHECK-NEXT:      (struct.new $generated_type$5
-;; CHECK-NEXT:       (ref.i31_shared
-;; CHECK-NEXT:        (i32.const 1)
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:       (struct.new $9
-;; CHECK-NEXT:        (i32.const -16384)
-;; CHECK-NEXT:        (ref.null (shared none))
-;; CHECK-NEXT:        (f64.const -nan:0xfffffffffff8f)
-;; CHECK-NEXT:        (v128.const i32x4 0x00f000ed 0x0086e500 0x69004c00 0x78abc94a)
-;; CHECK-NEXT:        (ref.null (shared none))
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:       (struct.new $7
-;; CHECK-NEXT:        (i32.const -28307)
-;; CHECK-NEXT:        (ref.null (shared none))
-;; CHECK-NEXT:        (f64.const -0.138)
-;; CHECK-NEXT:        (v128.const i32x4 0x20000000 0x41600000 0xffffffdb 0xffffffff)
-;; CHECK-NEXT:        (struct.new $generated_type$5
-;; CHECK-NEXT:         (ref.i31_shared
-;; CHECK-NEXT:          (i32.const 2147483647)
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:         (struct.new $9
-;; CHECK-NEXT:          (i32.const -68)
-;; CHECK-NEXT:          (ref.null (shared none))
-;; CHECK-NEXT:          (f64.const 4067708437)
-;; CHECK-NEXT:          (v128.const i32x4 0xff000000 0x41efffff 0xff7126e9 0xc1cfffff)
-;; CHECK-NEXT:          (ref.null (shared none))
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:         (ref.null (shared none))
-;; CHECK-NEXT:         (struct.new_default $7)
-;; CHECK-NEXT:         (i32.const 33554433)
-;; CHECK-NEXT:         (i32.const 1)
-;; CHECK-NEXT:         (struct.new_default $5)
-;; CHECK-NEXT:        )
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:       (ref.null (shared none))
-;; CHECK-NEXT:       (i32.const 134217728)
-;; CHECK-NEXT:       (i32.const -98)
-;; CHECK-NEXT:       (struct.new_default $5)
-;; CHECK-NEXT:      )
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (i32.const 65525)
-;; CHECK-NEXT:     (i32.const -2985)
-;; CHECK-NEXT:     (ref.null (shared none))
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (i32.const -563587298)
-;; CHECK-NEXT:   (i32.const -2932924)
-;; CHECK-NEXT:   (ref.null (shared none))
-;; CHECK-NEXT:  )
-;; CHECK-NEXT: ))
-
-;; CHECK:      (global $global$_10 eqref (ref.null none))
-
-;; CHECK:      (global $global$_11 stringref (ref.null noextern))
-
-;; CHECK:      (global $global$_12 (ref $generated_type$4) (struct.new $generated_type$4
-;; CHECK-NEXT:  (i32.const 1073741824)
-;; CHECK-NEXT:  (ref.null (shared none))
-;; CHECK-NEXT:  (f64.const 4294967213)
-;; CHECK-NEXT:  (v128.const i32x4 0x0000008a 0x00400000 0x7fffffff 0xf2265e73)
-;; CHECK-NEXT:  (struct.new $generated_type$5
-;; CHECK-NEXT:   (ref.i31_shared
-;; CHECK-NEXT:    (i32.const -19423)
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (struct.new_default $9)
-;; CHECK-NEXT:   (struct.new_default $7)
-;; CHECK-NEXT:   (struct.new_default $7)
-;; CHECK-NEXT:   (i32.const -128)
-;; CHECK-NEXT:   (i32.const -15)
-;; CHECK-NEXT:   (struct.new $5
-;; CHECK-NEXT:    (i32.const 32767)
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT: ))
-
-;; CHECK:      (global $global$_13 i64 (i64.const -32768))
-
-;; CHECK:      (global $global$_14 i32 (i32.const -7381244))
-
-;; CHECK:      (global $global$_15 (mut (tuple i32 (ref null $8) exnref f32 i64 stringref)) (tuple.make 6
-;; CHECK-NEXT:  (i32.const -13)
-;; CHECK-NEXT:  (ref.null none)
-;; CHECK-NEXT:  (ref.null noexn)
-;; CHECK-NEXT:  (f32.const 3402823466385288598117041e14)
-;; CHECK-NEXT:  (i64.const 45886)
-;; CHECK-NEXT:  (string.const "\ed\bd\88")
-;; CHECK-NEXT: ))
-
-;; CHECK:      (global $global$_16 i32 (global.get $global$_14))
-
-;; CHECK:      (global $global$_17 f32 (f32.const 9223372036854775808))
-
-;; CHECK:      (global $global$_18 (ref null $9) (global.get $global$_5))
-
-;; CHECK:      (global $global$_19 (ref $0) (ref.func $import))
-
-;; CHECK:      (global $global$_20 (ref $9) (struct.new $9
-;; CHECK-NEXT:  (i32.const 33375)
-;; CHECK-NEXT:  (ref.null (shared none))
-;; CHECK-NEXT:  (f64.const -nan:0xfffffffffffba)
-;; CHECK-NEXT:  (v128.const i32x4 0x00000003 0x00000000 0xc0000001 0xffffffff)
-;; CHECK-NEXT:  (ref.null (shared none))
-;; CHECK-NEXT: ))
-
-;; CHECK:      (global $global$_21 funcref (ref.func $import))
-
-;; CHECK:      (global $hangLimit (mut i32) (i32.const 100))
-
-;; CHECK:      (memory $0 i64 16 17 shared)
-
-;; CHECK:      (data $0 "\b5\08ANA\b2\ae")
-
-;; CHECK:      (data $1 (i64.const 0) "\c4I5\a6\8d>\c4\a1g\ff\a3\daf\90XX\14\b4n%\10\e2")
-
-;; CHECK:      (data $2 "\f8\ea\df\82sNi\14s")
-
-;; CHECK:      (data $3 (i64.const 22) "\d6=\8c\91\b9\c7\18\af@")
-
-;; CHECK:      (table $fuzzing_table 5 funcref)
-
-;; CHECK:      (table $exnref_table 8 exnref)
-
-;; CHECK:      (elem $elem$ (table $fuzzing_table) (i32.const 0) func $func_12 $func_12 $func_14)
-
-;; CHECK:      (elem declare func $func $import $log-f32 $log-i64)
-
-;; CHECK:      (tag $tag$ (type $14) (param f64))
-
-;; CHECK:      (export "table" (table $fuzzing_table))
-
-;; CHECK:      (export "func" (func $func))
-
-;; CHECK:      (export "func_12" (func $func_12))
-
-;; CHECK:      (export "func_13" (func $func_13))
-
-;; CHECK:      (export "func_14" (func $func_14))
-
-;; CHECK:      (export "func_14_invoker" (func $func_14_invoker))
-
-;; CHECK:      (export "func_16" (func $func_16))
-
-;; CHECK:      (func $import (type $0)
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (if
-;; CHECK-NEXT:    (i32.eqz
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:    (then
-;; CHECK-NEXT:     (global.set $hangLimit
-;; CHECK-NEXT:      (i32.const 100)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (unreachable)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (global.set $hangLimit
-;; CHECK-NEXT:    (i32.sub
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:     (i32.const 1)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT:  (nop)
-;; CHECK-NEXT: )
-
-;; CHECK:      (func $func (type $0)
-;; CHECK-NEXT:  (local $0 i32)
-;; CHECK-NEXT:  (local $1 (tuple i64 f64 v128 stringref funcref))
-;; CHECK-NEXT:  (local $2 (ref null $1))
-;; CHECK-NEXT:  (local $3 arrayref)
-;; CHECK-NEXT:  (local $4 f64)
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (if
-;; CHECK-NEXT:    (i32.eqz
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:    (then
-;; CHECK-NEXT:     (global.set $hangLimit
-;; CHECK-NEXT:      (i32.const 100)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (unreachable)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (global.set $hangLimit
-;; CHECK-NEXT:    (i32.sub
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:     (i32.const 1)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT:  (block $label$0
-;; CHECK-NEXT:   (call $log-f32
-;; CHECK-NEXT:    (f32.const -68719476736)
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT: )
-
-;; CHECK:      (func $func_12 (type $12) (param $0 i32)
-;; CHECK-NEXT:  (local $1 (tuple i32 f32 f32 arrayref))
-;; CHECK-NEXT:  (local $2 (ref null $generated_type$4))
-;; CHECK-NEXT:  (local $3 f64)
-;; CHECK-NEXT:  (local $4 (ref $9))
-;; CHECK-NEXT:  (local $5 (ref struct))
-;; CHECK-NEXT:  (local $6 (ref $generated_type$11))
-;; CHECK-NEXT:  (local $7 (ref $5))
-;; CHECK-NEXT:  (local $8 v128)
-;; CHECK-NEXT:  (local $9 f64)
-;; CHECK-NEXT:  (local $10 (ref func))
-;; CHECK-NEXT:  (local $11 (ref $6))
-;; CHECK-NEXT:  (local $12 i64)
-;; CHECK-NEXT:  (local $13 structref)
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (if
-;; CHECK-NEXT:    (i32.eqz
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:    (then
-;; CHECK-NEXT:     (global.set $hangLimit
-;; CHECK-NEXT:      (i32.const 100)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (unreachable)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (global.set $hangLimit
-;; CHECK-NEXT:    (i32.sub
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:     (i32.const 1)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (local.set $7
-;; CHECK-NEXT:    (struct.new_default $5)
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (block
-;; CHECK-NEXT:    (local.set $6
-;; CHECK-NEXT:     (struct.new $generated_type$11
-;; CHECK-NEXT:      (global.get $global$_16)
-;; CHECK-NEXT:      (ref.null (shared none))
-;; CHECK-NEXT:      (f64.const -nan:0xfffffffffffb8)
-;; CHECK-NEXT:      (local.get $8)
-;; CHECK-NEXT:      (struct.new $generated_type$5
-;; CHECK-NEXT:       (ref.i31_shared
-;; CHECK-NEXT:        (i32.const 127)
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:       (global.get $global$_20)
-;; CHECK-NEXT:       (struct.new_default $7)
-;; CHECK-NEXT:       (struct.new_default $7)
-;; CHECK-NEXT:       (i32.const -2147483648)
-;; CHECK-NEXT:       (local.get $0)
-;; CHECK-NEXT:       (struct.new $5
-;; CHECK-NEXT:        (i32.const -536870913)
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:      )
-;; CHECK-NEXT:      (struct.new_default $9)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:    (block
-;; CHECK-NEXT:     (local.set $4
-;; CHECK-NEXT:      (struct.new_default $9)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (block $label$0
-;; CHECK-NEXT:      (nop)
-;; CHECK-NEXT:      (nop)
-;; CHECK-NEXT:      (loop $label$1
-;; CHECK-NEXT:       (block
-;; CHECK-NEXT:        (if
-;; CHECK-NEXT:         (i32.eqz
-;; CHECK-NEXT:          (global.get $hangLimit)
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:         (then
-;; CHECK-NEXT:          (global.set $hangLimit
-;; CHECK-NEXT:           (i32.const 100)
-;; CHECK-NEXT:          )
-;; CHECK-NEXT:          (unreachable)
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:        )
-;; CHECK-NEXT:        (global.set $hangLimit
-;; CHECK-NEXT:         (i32.sub
-;; CHECK-NEXT:          (global.get $hangLimit)
-;; CHECK-NEXT:          (i32.const 1)
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:        )
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:       (block
-;; CHECK-NEXT:        (block $label$2
-;; CHECK-NEXT:         (atomic.fence)
-;; CHECK-NEXT:         (if
-;; CHECK-NEXT:          (i32.eqz
-;; CHECK-NEXT:           (ref.eq
-;; CHECK-NEXT:            (struct.new_default $10)
-;; CHECK-NEXT:            (struct.new_default $10)
-;; CHECK-NEXT:           )
-;; CHECK-NEXT:          )
-;; CHECK-NEXT:          (then
-;; CHECK-NEXT:           (block $label$3
-;; CHECK-NEXT:            (call $table-set
-;; CHECK-NEXT:             (local.tee $0
-;; CHECK-NEXT:              (local.tee $0
-;; CHECK-NEXT:               (tuple.extract 2 0
-;; CHECK-NEXT:                (tuple.make 2
-;; CHECK-NEXT:                 (i32.const 16777216)
-;; CHECK-NEXT:                 (ref.null noextern)
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (ref.func $func_12)
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:            (i32.atomic.store offset=22
-;; CHECK-NEXT:             (i64.and
-;; CHECK-NEXT:              (global.get $global$_13)
-;; CHECK-NEXT:              (i64.const 15)
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (i32.const -126)
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:           )
-;; CHECK-NEXT:          )
-;; CHECK-NEXT:          (else
-;; CHECK-NEXT:           (loop $label$4
-;; CHECK-NEXT:            (block
-;; CHECK-NEXT:             (if
-;; CHECK-NEXT:              (i32.eqz
-;; CHECK-NEXT:               (global.get $hangLimit)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:              (then
-;; CHECK-NEXT:               (global.set $hangLimit
-;; CHECK-NEXT:                (i32.const 100)
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:               (unreachable)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (global.set $hangLimit
-;; CHECK-NEXT:              (i32.sub
-;; CHECK-NEXT:               (global.get $hangLimit)
-;; CHECK-NEXT:               (i32.const 1)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:            (block
-;; CHECK-NEXT:             (block $label$5
-;; CHECK-NEXT:              (nop)
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (br_if $label$4
-;; CHECK-NEXT:              (string.measure_wtf16
-;; CHECK-NEXT:               (string.const "\ed\bd\88")
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (loop $label$6
-;; CHECK-NEXT:              (block
-;; CHECK-NEXT:               (if
-;; CHECK-NEXT:                (i32.eqz
-;; CHECK-NEXT:                 (global.get $hangLimit)
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (then
-;; CHECK-NEXT:                 (global.set $hangLimit
-;; CHECK-NEXT:                  (i32.const 100)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (unreachable)
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:               (global.set $hangLimit
-;; CHECK-NEXT:                (i32.sub
-;; CHECK-NEXT:                 (global.get $hangLimit)
-;; CHECK-NEXT:                 (i32.const 1)
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:              (block
-;; CHECK-NEXT:               (table.set $fuzzing_table
-;; CHECK-NEXT:                (i32.const 0)
-;; CHECK-NEXT:                (ref.null nofunc)
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:               (br_if $label$6
-;; CHECK-NEXT:                (loop $label$7 (result i32)
-;; CHECK-NEXT:                 (block
-;; CHECK-NEXT:                  (if
-;; CHECK-NEXT:                   (i32.eqz
-;; CHECK-NEXT:                    (global.get $hangLimit)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (then
-;; CHECK-NEXT:                    (global.set $hangLimit
-;; CHECK-NEXT:                     (i32.const 100)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (unreachable)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (global.set $hangLimit
-;; CHECK-NEXT:                   (i32.sub
-;; CHECK-NEXT:                    (global.get $hangLimit)
-;; CHECK-NEXT:                    (i32.const 1)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (block $label$8 (result i32)
-;; CHECK-NEXT:                  (br $label$0)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:               (atomic.fence)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:           )
-;; CHECK-NEXT:          )
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:        )
-;; CHECK-NEXT:        (br_if $label$1
-;; CHECK-NEXT:         (select
-;; CHECK-NEXT:          (if (result i32)
-;; CHECK-NEXT:           (i32.eqz
-;; CHECK-NEXT:            (local.get $0)
-;; CHECK-NEXT:           )
-;; CHECK-NEXT:           (then
-;; CHECK-NEXT:            (call $call-ref-catch
-;; CHECK-NEXT:             (if (result (ref func))
-;; CHECK-NEXT:              (ref.eq
-;; CHECK-NEXT:               (struct.new_default $10)
-;; CHECK-NEXT:               (struct.new_default $10)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:              (then
-;; CHECK-NEXT:               (block $label$31 (result (ref func))
-;; CHECK-NEXT:                (atomic.fence)
-;; CHECK-NEXT:                (ref.func $func)
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:              (else
-;; CHECK-NEXT:               (block $label$32 (result (ref func))
-;; CHECK-NEXT:                (loop $label$33
-;; CHECK-NEXT:                 (block
-;; CHECK-NEXT:                  (if
-;; CHECK-NEXT:                   (i32.eqz
-;; CHECK-NEXT:                    (global.get $hangLimit)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (then
-;; CHECK-NEXT:                    (global.set $hangLimit
-;; CHECK-NEXT:                     (i32.const 100)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (unreachable)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (global.set $hangLimit
-;; CHECK-NEXT:                   (i32.sub
-;; CHECK-NEXT:                    (global.get $hangLimit)
-;; CHECK-NEXT:                    (i32.const 1)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (block
-;; CHECK-NEXT:                  (nop)
-;; CHECK-NEXT:                  (br_if $label$33
-;; CHECK-NEXT:                   (i32.eqz
-;; CHECK-NEXT:                    (struct.get $9 0
-;; CHECK-NEXT:                     (global.get $global$_20)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (nop)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (local.tee $10
-;; CHECK-NEXT:                 (if (result (ref func))
-;; CHECK-NEXT:                  (i32.eqz
-;; CHECK-NEXT:                   (local.tee $0
-;; CHECK-NEXT:                    (i32.const 65444)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (then
-;; CHECK-NEXT:                   (br_table $label$0 $label$1 $label$0 $label$0 $label$1 $label$0 $label$0 $label$0
-;; CHECK-NEXT:                    (i32.shl
-;; CHECK-NEXT:                     (ref.eq
-;; CHECK-NEXT:                      (struct.new_default $10)
-;; CHECK-NEXT:                      (if (result (ref $2))
-;; CHECK-NEXT:                       (i32.eqz
-;; CHECK-NEXT:                        (i32.const 128)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (then
-;; CHECK-NEXT:                        (local.tee $11
-;; CHECK-NEXT:                         (global.get $global$_6)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (else
-;; CHECK-NEXT:                        (try_table (result (ref none)) (catch_all $label$0)
-;; CHECK-NEXT:                         (ref.as_non_null
-;; CHECK-NEXT:                          (ref.null none)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (block $label$34 (result i32)
-;; CHECK-NEXT:                      (call_ref $0
-;; CHECK-NEXT:                       (ref.func $import)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (br $label$1)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (else
-;; CHECK-NEXT:                   (if (result (ref $0))
-;; CHECK-NEXT:                    (i32.load16_u offset=3
-;; CHECK-NEXT:                     (i64.and
-;; CHECK-NEXT:                      (try_table (result i64) (catch_all $label$1)
-;; CHECK-NEXT:                       (i64.const -4398046511104)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (i64.const 15)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (then
-;; CHECK-NEXT:                     (block $label$35 (result (ref $0))
-;; CHECK-NEXT:                      (call $table-set
-;; CHECK-NEXT:                       (i8x16.extract_lane_s 10
-;; CHECK-NEXT:                        (block $label$36 (result v128)
-;; CHECK-NEXT:                         (nop)
-;; CHECK-NEXT:                         (br $label$0)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (ref.func $func_12)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (loop $label$37 (result (ref $0))
-;; CHECK-NEXT:                       (block
-;; CHECK-NEXT:                        (if
-;; CHECK-NEXT:                         (i32.eqz
-;; CHECK-NEXT:                          (global.get $hangLimit)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                         (then
-;; CHECK-NEXT:                          (global.set $hangLimit
-;; CHECK-NEXT:                           (i32.const 100)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                          (unreachable)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (global.set $hangLimit
-;; CHECK-NEXT:                         (i32.sub
-;; CHECK-NEXT:                          (global.get $hangLimit)
-;; CHECK-NEXT:                          (i32.const 1)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (block (result (ref $0))
-;; CHECK-NEXT:                        (block $label$38
-;; CHECK-NEXT:                         (struct.set $9 2
-;; CHECK-NEXT:                          (local.get $4)
-;; CHECK-NEXT:                          (f64.const -4398046511104)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                         (call $table-set
-;; CHECK-NEXT:                          (local.get $0)
-;; CHECK-NEXT:                          (call $table-get
-;; CHECK-NEXT:                           (loop $label$39 (result i32)
-;; CHECK-NEXT:                            (block
-;; CHECK-NEXT:                             (if
-;; CHECK-NEXT:                              (i32.eqz
-;; CHECK-NEXT:                               (global.get $hangLimit)
-;; CHECK-NEXT:                              )
-;; CHECK-NEXT:                              (then
-;; CHECK-NEXT:                               (global.set $hangLimit
-;; CHECK-NEXT:                                (i32.const 100)
-;; CHECK-NEXT:                               )
-;; CHECK-NEXT:                               (unreachable)
-;; CHECK-NEXT:                              )
-;; CHECK-NEXT:                             )
-;; CHECK-NEXT:                             (global.set $hangLimit
-;; CHECK-NEXT:                              (i32.sub
-;; CHECK-NEXT:                               (global.get $hangLimit)
-;; CHECK-NEXT:                               (i32.const 1)
-;; CHECK-NEXT:                              )
-;; CHECK-NEXT:                             )
-;; CHECK-NEXT:                            )
-;; CHECK-NEXT:                            (i32.const 10338)
-;; CHECK-NEXT:                           )
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (br_if $label$37
-;; CHECK-NEXT:                         (block $label$40 (result i32)
-;; CHECK-NEXT:                          (nop)
-;; CHECK-NEXT:                          (i32.atomic.load16_u offset=22
-;; CHECK-NEXT:                           (i64.and
-;; CHECK-NEXT:                            (i64.const -32768)
-;; CHECK-NEXT:                            (i64.const 15)
-;; CHECK-NEXT:                           )
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (ref.func $func)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (else
-;; CHECK-NEXT:                     (block $label$41
-;; CHECK-NEXT:                      (nop)
-;; CHECK-NEXT:                      (throw $tag$
-;; CHECK-NEXT:                       (f64.const -nan:0xffffffffffff2)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:           )
-;; CHECK-NEXT:           (else
-;; CHECK-NEXT:            (block $label$42 (result i32)
-;; CHECK-NEXT:             (call $log-v128
-;; CHECK-NEXT:              (v128.load offset=3 align=2
-;; CHECK-NEXT:               (i64.and
-;; CHECK-NEXT:                (loop $label$43 (result i64)
-;; CHECK-NEXT:                 (block
-;; CHECK-NEXT:                  (if
-;; CHECK-NEXT:                   (i32.eqz
-;; CHECK-NEXT:                    (global.get $hangLimit)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (then
-;; CHECK-NEXT:                    (global.set $hangLimit
-;; CHECK-NEXT:                     (i32.const 100)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (unreachable)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (global.set $hangLimit
-;; CHECK-NEXT:                   (i32.sub
-;; CHECK-NEXT:                    (global.get $hangLimit)
-;; CHECK-NEXT:                    (i32.const 1)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (block $label$44 (result i64)
-;; CHECK-NEXT:                  (drop
-;; CHECK-NEXT:                   (br_on_null $label$0
-;; CHECK-NEXT:                    (block (result (ref (exact $12)))
-;; CHECK-NEXT:                     (drop
-;; CHECK-NEXT:                      (br_on_null $label$0
-;; CHECK-NEXT:                       (block (result (ref string))
-;; CHECK-NEXT:                        (drop
-;; CHECK-NEXT:                         (br_on_null $label$1
-;; CHECK-NEXT:                          (ref.i31
-;; CHECK-NEXT:                           (i32.const 32767)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (string.const "\f0\90\8d\88\f0\90\8d\88\ed\bd\88")
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (ref.func $func_12)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (br $label$0)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (i64.const 15)
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (br $label$0)
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:           )
-;; CHECK-NEXT:          )
-;; CHECK-NEXT:          (select
-;; CHECK-NEXT:           (local.get $0)
-;; CHECK-NEXT:           (loop $label$46 (result i32)
-;; CHECK-NEXT:            (block
-;; CHECK-NEXT:             (if
-;; CHECK-NEXT:              (i32.eqz
-;; CHECK-NEXT:               (global.get $hangLimit)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:              (then
-;; CHECK-NEXT:               (global.set $hangLimit
-;; CHECK-NEXT:                (i32.const 100)
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:               (unreachable)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (global.set $hangLimit
-;; CHECK-NEXT:              (i32.sub
-;; CHECK-NEXT:               (global.get $hangLimit)
-;; CHECK-NEXT:               (i32.const 1)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:            (block (result i32)
-;; CHECK-NEXT:             (block $label$47
-;; CHECK-NEXT:              (struct.set $7 2
-;; CHECK-NEXT:               (struct.new $7
-;; CHECK-NEXT:                (i32.const -2)
-;; CHECK-NEXT:                (ref.null (shared none))
-;; CHECK-NEXT:                (f64.const -nan:0xfff81722f4d10)
-;; CHECK-NEXT:                (v128.const i32x4 0x00008001 0xffff8002 0xfe000001 0xffff9a40)
-;; CHECK-NEXT:                (ref.null (shared none))
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:               (tuple.extract 2 0
-;; CHECK-NEXT:                (tuple.make 2
-;; CHECK-NEXT:                 (f64.const 24109)
-;; CHECK-NEXT:                 (f32.const 3402823466385288598117041e14)
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:              (call $table-set
-;; CHECK-NEXT:               (local.get $0)
-;; CHECK-NEXT:               (ref.func $log-i64)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (br_if $label$46
-;; CHECK-NEXT:              (i32.eqz
-;; CHECK-NEXT:               (select
-;; CHECK-NEXT:                (ref.eq
-;; CHECK-NEXT:                 (if (result (ref $8))
-;; CHECK-NEXT:                  (i32.eqz
-;; CHECK-NEXT:                   (local.tee $0
-;; CHECK-NEXT:                    (global.get $global$_14)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (then
-;; CHECK-NEXT:                   (block $label$50 (result (ref $8))
-;; CHECK-NEXT:                    (array.new $8
-;; CHECK-NEXT:                     (local.get $6)
-;; CHECK-NEXT:                     (i32.const 1)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (else
-;; CHECK-NEXT:                   (block $label$51 (result (ref $8))
-;; CHECK-NEXT:                    (loop $label$52
-;; CHECK-NEXT:                     (block
-;; CHECK-NEXT:                      (if
-;; CHECK-NEXT:                       (i32.eqz
-;; CHECK-NEXT:                        (global.get $hangLimit)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (then
-;; CHECK-NEXT:                        (global.set $hangLimit
-;; CHECK-NEXT:                         (i32.const 100)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (unreachable)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (global.set $hangLimit
-;; CHECK-NEXT:                       (i32.sub
-;; CHECK-NEXT:                        (global.get $hangLimit)
-;; CHECK-NEXT:                        (i32.const 1)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (block
-;; CHECK-NEXT:                      (block $label$53
-;; CHECK-NEXT:                       (call $log-f64
-;; CHECK-NEXT:                        (f64x2.extract_lane 1
-;; CHECK-NEXT:                         (v128.const i32x4 0x46f46e00 0x746d6f5c 0xdf000000 0xdf000000)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (call $log-f32
-;; CHECK-NEXT:                        (f32.const 4398046511104)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (br_if $label$52
-;; CHECK-NEXT:                       (block $label$54 (result i32)
-;; CHECK-NEXT:                        (call $func)
-;; CHECK-NEXT:                        (local.tee $0
-;; CHECK-NEXT:                         (ref.eq
-;; CHECK-NEXT:                          (array.new_fixed $13 0)
-;; CHECK-NEXT:                          (local.get $13)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (call $throw
-;; CHECK-NEXT:                       (i32.const 0)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (array.new $8
-;; CHECK-NEXT:                     (struct.new_default $generated_type$4)
-;; CHECK-NEXT:                     (i32.const 13)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (struct.new_default $10)
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (local.tee $0
-;; CHECK-NEXT:                 (block $label$55 (result i32)
-;; CHECK-NEXT:                  (call $table-set
-;; CHECK-NEXT:                   (string.encode_wtf16_array
-;; CHECK-NEXT:                    (loop $label$56 (result (ref string))
-;; CHECK-NEXT:                     (block
-;; CHECK-NEXT:                      (if
-;; CHECK-NEXT:                       (i32.eqz
-;; CHECK-NEXT:                        (global.get $hangLimit)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (then
-;; CHECK-NEXT:                        (global.set $hangLimit
-;; CHECK-NEXT:                         (i32.const 100)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (unreachable)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (global.set $hangLimit
-;; CHECK-NEXT:                       (i32.sub
-;; CHECK-NEXT:                        (global.get $hangLimit)
-;; CHECK-NEXT:                        (i32.const 1)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (block (result (ref string))
-;; CHECK-NEXT:                      (block $label$57
-;; CHECK-NEXT:                       (call $log-i64
-;; CHECK-NEXT:                        (local.get $12)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (nop)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (br_if $label$56
-;; CHECK-NEXT:                       (i32.eqz
-;; CHECK-NEXT:                        (local.get $0)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (string.const "\e2\82\ac938\ed\a0\80")
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (array.new_default $23
-;; CHECK-NEXT:                     (i32.const 72)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (i32.atomic.load16_u offset=22
-;; CHECK-NEXT:                     (i64.and
-;; CHECK-NEXT:                      (global.get $global$_13)
-;; CHECK-NEXT:                      (i64.const 15)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (call $table-get
-;; CHECK-NEXT:                    (local.get $0)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (i32.atomic.rmw16.xchg_u offset=3
-;; CHECK-NEXT:                   (i64.and
-;; CHECK-NEXT:                    (i64.extend8_s
-;; CHECK-NEXT:                     (local.get $12)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (i64.const 15)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (i8x16.extract_lane_s 15
-;; CHECK-NEXT:                    (i32x4.splat
-;; CHECK-NEXT:                     (global.get $global$_14)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (struct.get $generated_type$11 0
-;; CHECK-NEXT:                 (struct.new $generated_type$11
-;; CHECK-NEXT:                  (i64.lt_s
-;; CHECK-NEXT:                   (global.get $global$_13)
-;; CHECK-NEXT:                   (local.get $12)
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (ref.null (shared none))
-;; CHECK-NEXT:                  (f64.const 3)
-;; CHECK-NEXT:                  (v128.load offset=3 align=8
-;; CHECK-NEXT:                   (i64.and
-;; CHECK-NEXT:                    (loop $label$48 (result i64)
-;; CHECK-NEXT:                     (block
-;; CHECK-NEXT:                      (if
-;; CHECK-NEXT:                       (i32.eqz
-;; CHECK-NEXT:                        (global.get $hangLimit)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (then
-;; CHECK-NEXT:                        (global.set $hangLimit
-;; CHECK-NEXT:                         (i32.const 100)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (unreachable)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (global.set $hangLimit
-;; CHECK-NEXT:                       (i32.sub
-;; CHECK-NEXT:                        (global.get $hangLimit)
-;; CHECK-NEXT:                        (i32.const 1)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (block (result i64)
-;; CHECK-NEXT:                      (block $label$49
-;; CHECK-NEXT:                       (try_table (catch_all $label$0)
-;; CHECK-NEXT:                        (atomic.fence)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (local.set $7
-;; CHECK-NEXT:                        (local.get $7)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (br_if $label$48
-;; CHECK-NEXT:                       (i32.eqz
-;; CHECK-NEXT:                        (i32.const -18605)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (local.tee $12
-;; CHECK-NEXT:                       (local.get $12)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (i64.const 15)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (struct.new $generated_type$5
-;; CHECK-NEXT:                   (ref.i31_shared
-;; CHECK-NEXT:                    (i32.const -569297635)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (struct.new_default $9)
-;; CHECK-NEXT:                   (struct.new_default $7)
-;; CHECK-NEXT:                   (ref.null (shared none))
-;; CHECK-NEXT:                   (local.get $0)
-;; CHECK-NEXT:                   (i32.const 20501)
-;; CHECK-NEXT:                   (ref.null (shared none))
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (struct.new_default $24)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (i16x8.extract_lane_u 2
-;; CHECK-NEXT:              (f64x2.splat
-;; CHECK-NEXT:               (f64.const -16383.795)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:           )
-;; CHECK-NEXT:           (local.get $0)
-;; CHECK-NEXT:          )
-;; CHECK-NEXT:          (string.measure_wtf16
-;; CHECK-NEXT:           (block $label$9 (result (ref string))
-;; CHECK-NEXT:            (try
-;; CHECK-NEXT:             (do
-;; CHECK-NEXT:              (drop
-;; CHECK-NEXT:               (br_on_cast $label$9 (ref string) (ref string)
-;; CHECK-NEXT:                (br_if $label$9
-;; CHECK-NEXT:                 (if (result (ref string))
-;; CHECK-NEXT:                  (i32.eqz
-;; CHECK-NEXT:                   (local.get $0)
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (then
-;; CHECK-NEXT:                   (block $label$10 (result (ref string))
-;; CHECK-NEXT:                    (i32.atomic.store offset=22
-;; CHECK-NEXT:                     (i64.and
-;; CHECK-NEXT:                      (i64.const 4294941230)
-;; CHECK-NEXT:                      (i64.const 15)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (local.tee $0
-;; CHECK-NEXT:                      (i32.const -65)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (br $label$1)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (else
-;; CHECK-NEXT:                   (block $label$11 (result (ref string))
-;; CHECK-NEXT:                    (nop)
-;; CHECK-NEXT:                    (select (result (ref string))
-;; CHECK-NEXT:                     (if (result (ref string))
-;; CHECK-NEXT:                      (i32.eqz
-;; CHECK-NEXT:                       (local.get $0)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (then
-;; CHECK-NEXT:                       (string.const "\c2\a3\c2\a3\c2\a3")
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (else
-;; CHECK-NEXT:                       (string.const "\c2\a3\ed\a0\80")
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (block $label$12 (result (ref string))
-;; CHECK-NEXT:                      (br $label$0)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (ref.is_null
-;; CHECK-NEXT:                      (struct.new_default $10)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (global.get $global$_14)
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (catch $tag$
-;; CHECK-NEXT:              (local.set $3
-;; CHECK-NEXT:               (pop f64)
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:              (loop $label$13
-;; CHECK-NEXT:               (block
-;; CHECK-NEXT:                (if
-;; CHECK-NEXT:                 (i32.eqz
-;; CHECK-NEXT:                  (global.get $hangLimit)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (then
-;; CHECK-NEXT:                  (global.set $hangLimit
-;; CHECK-NEXT:                   (i32.const 100)
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (unreachable)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (global.set $hangLimit
-;; CHECK-NEXT:                 (i32.sub
-;; CHECK-NEXT:                  (global.get $hangLimit)
-;; CHECK-NEXT:                  (i32.const 1)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:               (block
-;; CHECK-NEXT:                (drop
-;; CHECK-NEXT:                 (br_on_null $label$13
-;; CHECK-NEXT:                  (local.tee $4
-;; CHECK-NEXT:                   (struct.new $9
-;; CHECK-NEXT:                    (global.get $global$_16)
-;; CHECK-NEXT:                    (ref.null (shared none))
-;; CHECK-NEXT:                    (global.get $global$_4)
-;; CHECK-NEXT:                    (v128.const i32x4 0x0000fff6 0x8002fffe 0xff009b21 0x003fffc6)
-;; CHECK-NEXT:                    (ref.null (shared none))
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (br_if $label$13
-;; CHECK-NEXT:                 (i32.eqz
-;; CHECK-NEXT:                  (local.get $0)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (loop $label$14
-;; CHECK-NEXT:                 (block
-;; CHECK-NEXT:                  (if
-;; CHECK-NEXT:                   (i32.eqz
-;; CHECK-NEXT:                    (global.get $hangLimit)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (then
-;; CHECK-NEXT:                    (global.set $hangLimit
-;; CHECK-NEXT:                     (i32.const 100)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (unreachable)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (global.set $hangLimit
-;; CHECK-NEXT:                   (i32.sub
-;; CHECK-NEXT:                    (global.get $hangLimit)
-;; CHECK-NEXT:                    (i32.const 1)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (block
-;; CHECK-NEXT:                  (block $label$15
-;; CHECK-NEXT:                   (memory.fill
-;; CHECK-NEXT:                    (i64.and
-;; CHECK-NEXT:                     (i64.const -26772)
-;; CHECK-NEXT:                     (i64.const 15)
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (ref.eq
-;; CHECK-NEXT:                     (local.tee $5
-;; CHECK-NEXT:                      (struct.new_default $10)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (ref.as_non_null
-;; CHECK-NEXT:                      (ref.null none)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (i64.const -9223372036854775808)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (if
-;; CHECK-NEXT:                    (i32.eqz
-;; CHECK-NEXT:                     (memory.atomic.notify offset=22
-;; CHECK-NEXT:                      (i64.and
-;; CHECK-NEXT:                       (i64.const 9223372036854775807)
-;; CHECK-NEXT:                       (i64.const 15)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (block $label$16 (result i32)
-;; CHECK-NEXT:                       (nop)
-;; CHECK-NEXT:                       (local.get $0)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (then
-;; CHECK-NEXT:                     (br_if $label$1
-;; CHECK-NEXT:                      (i32.eqz
-;; CHECK-NEXT:                       (i32.const 8388608)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (br_if $label$14
-;; CHECK-NEXT:                   (call $call-ref-catch
-;; CHECK-NEXT:                    (global.get $global$_19)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (nop)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:             (catch_all
-;; CHECK-NEXT:              (struct.set $generated_type$11 2
-;; CHECK-NEXT:               (local.tee $6
-;; CHECK-NEXT:                (ref.cast (ref (shared none))
-;; CHECK-NEXT:                 (struct.new_default $1)
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:               (if (result f64)
-;; CHECK-NEXT:                (f32.ne
-;; CHECK-NEXT:                 (if (result f32)
-;; CHECK-NEXT:                  (struct.get_u $5 0
-;; CHECK-NEXT:                   (local.tee $7
-;; CHECK-NEXT:                    (ref.as_non_null
-;; CHECK-NEXT:                     (ref.null (shared none))
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (then
-;; CHECK-NEXT:                   (block $label$17 (result f32)
-;; CHECK-NEXT:                    (f32.const -nan:0x7fff84)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (else
-;; CHECK-NEXT:                   (block $label$18 (result f32)
-;; CHECK-NEXT:                    (if
-;; CHECK-NEXT:                     (i32.eqz
-;; CHECK-NEXT:                      (loop $label$19 (result i32)
-;; CHECK-NEXT:                       (block
-;; CHECK-NEXT:                        (if
-;; CHECK-NEXT:                         (i32.eqz
-;; CHECK-NEXT:                          (global.get $hangLimit)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                         (then
-;; CHECK-NEXT:                          (global.set $hangLimit
-;; CHECK-NEXT:                           (i32.const 100)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                          (unreachable)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (global.set $hangLimit
-;; CHECK-NEXT:                         (i32.sub
-;; CHECK-NEXT:                          (global.get $hangLimit)
-;; CHECK-NEXT:                          (i32.const 1)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (i32.const -129)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (then
-;; CHECK-NEXT:                      (loop $label$20
-;; CHECK-NEXT:                       (block
-;; CHECK-NEXT:                        (if
-;; CHECK-NEXT:                         (i32.eqz
-;; CHECK-NEXT:                          (global.get $hangLimit)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                         (then
-;; CHECK-NEXT:                          (global.set $hangLimit
-;; CHECK-NEXT:                           (i32.const 100)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                          (unreachable)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (global.set $hangLimit
-;; CHECK-NEXT:                         (i32.sub
-;; CHECK-NEXT:                          (global.get $hangLimit)
-;; CHECK-NEXT:                          (i32.const 1)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (block
-;; CHECK-NEXT:                        (nop)
-;; CHECK-NEXT:                        (br_if $label$20
-;; CHECK-NEXT:                         (local.get $0)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (nop)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (else
-;; CHECK-NEXT:                      (block $label$21
-;; CHECK-NEXT:                       (br_if $label$21
-;; CHECK-NEXT:                        (block $label$22 (result i32)
-;; CHECK-NEXT:                         (nop)
-;; CHECK-NEXT:                         (select
-;; CHECK-NEXT:                          (i32.const 268435456)
-;; CHECK-NEXT:                          (if (result i32)
-;; CHECK-NEXT:                           (i32.eqz
-;; CHECK-NEXT:                            (local.tee $0
-;; CHECK-NEXT:                             (local.get $0)
-;; CHECK-NEXT:                            )
-;; CHECK-NEXT:                           )
-;; CHECK-NEXT:                           (then
-;; CHECK-NEXT:                            (local.get $0)
-;; CHECK-NEXT:                           )
-;; CHECK-NEXT:                           (else
-;; CHECK-NEXT:                            (local.get $0)
-;; CHECK-NEXT:                           )
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                          (try_table (result i32) (catch_all $label$0)
-;; CHECK-NEXT:                           (i32.const 81)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (table.set $fuzzing_table
-;; CHECK-NEXT:                        (i32.const 1)
-;; CHECK-NEXT:                        (call $table-get
-;; CHECK-NEXT:                         (if (result i32)
-;; CHECK-NEXT:                          (i32.const -2048)
-;; CHECK-NEXT:                          (then
-;; CHECK-NEXT:                           (local.get $0)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                          (else
-;; CHECK-NEXT:                           (i32.const -77)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (br $label$1)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                 (f32.div
-;; CHECK-NEXT:                  (tuple.extract 2 0
-;; CHECK-NEXT:                   (tuple.make 2
-;; CHECK-NEXT:                    (f32.const 2147483648)
-;; CHECK-NEXT:                    (f64.const 18)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (loop $label$23 (result f32)
-;; CHECK-NEXT:                   (block
-;; CHECK-NEXT:                    (if
-;; CHECK-NEXT:                     (i32.eqz
-;; CHECK-NEXT:                      (global.get $hangLimit)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (then
-;; CHECK-NEXT:                      (global.set $hangLimit
-;; CHECK-NEXT:                       (i32.const 100)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (unreachable)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (global.set $hangLimit
-;; CHECK-NEXT:                     (i32.sub
-;; CHECK-NEXT:                      (global.get $hangLimit)
-;; CHECK-NEXT:                      (i32.const 1)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (block (result f32)
-;; CHECK-NEXT:                    (nop)
-;; CHECK-NEXT:                    (br_if $label$23
-;; CHECK-NEXT:                     (i16x8.extract_lane_u 0
-;; CHECK-NEXT:                      (local.get $8)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (f32.const -2147483648)
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (then
-;; CHECK-NEXT:                 (block $label$24 (result f64)
-;; CHECK-NEXT:                  (nop)
-;; CHECK-NEXT:                  (br $label$0)
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:                (else
-;; CHECK-NEXT:                 (block $label$25 (result f64)
-;; CHECK-NEXT:                  (call_ref $15
-;; CHECK-NEXT:                   (f32.const 2199023255552)
-;; CHECK-NEXT:                   (ref.func $log-f32)
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                  (loop $label$26 (result f64)
-;; CHECK-NEXT:                   (block
-;; CHECK-NEXT:                    (if
-;; CHECK-NEXT:                     (i32.eqz
-;; CHECK-NEXT:                      (global.get $hangLimit)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (then
-;; CHECK-NEXT:                      (global.set $hangLimit
-;; CHECK-NEXT:                       (i32.const 100)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (unreachable)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (global.set $hangLimit
-;; CHECK-NEXT:                     (i32.sub
-;; CHECK-NEXT:                      (global.get $hangLimit)
-;; CHECK-NEXT:                      (i32.const 1)
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                   (block (result f64)
-;; CHECK-NEXT:                    (block $label$27
-;; CHECK-NEXT:                     (call $log-f64
-;; CHECK-NEXT:                      (f64.convert_i32_u
-;; CHECK-NEXT:                       (if (result i32)
-;; CHECK-NEXT:                        (i32.eqz
-;; CHECK-NEXT:                         (i32.const -7)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (then
-;; CHECK-NEXT:                         (i32.const -110)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                        (else
-;; CHECK-NEXT:                         (i32.const -32162)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (br_if $label$26
-;; CHECK-NEXT:                     (i32.atomic.load16_u offset=22
-;; CHECK-NEXT:                      (i64.and
-;; CHECK-NEXT:                       (i64.const -6204899)
-;; CHECK-NEXT:                       (i64.const 15)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                    (try (result f64)
-;; CHECK-NEXT:                     (do
-;; CHECK-NEXT:                      (f64x2.extract_lane 1
-;; CHECK-NEXT:                       (block $label$28 (result v128)
-;; CHECK-NEXT:                        (local.get $8)
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                     (catch $tag$
-;; CHECK-NEXT:                      (local.set $9
-;; CHECK-NEXT:                       (pop f64)
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                      (if (result f64)
-;; CHECK-NEXT:                       (i32.load16_u offset=22
-;; CHECK-NEXT:                        (i64.and
-;; CHECK-NEXT:                         (i64.const -19)
-;; CHECK-NEXT:                         (i64.const 15)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (then
-;; CHECK-NEXT:                        (block $label$29 (result f64)
-;; CHECK-NEXT:                         (call $log-v128
-;; CHECK-NEXT:                          (local.tee $8
-;; CHECK-NEXT:                           (v128.const i32x4 0x0dfff881 0x012638f1 0x69d9009f 0x00e0012a)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                         (br $label$26)
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                       (else
-;; CHECK-NEXT:                        (block $label$30 (result f64)
-;; CHECK-NEXT:                         (call $table-set
-;; CHECK-NEXT:                          (local.get $0)
-;; CHECK-NEXT:                          (call $table-get
-;; CHECK-NEXT:                           (local.get $0)
-;; CHECK-NEXT:                          )
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                         (try_table (result f64) (catch $tag$ $label$25) (catch $tag$ $label$30) (catch $tag$ $label$30)
-;; CHECK-NEXT:                          (f64.const 1797693134862315708145274e284)
-;; CHECK-NEXT:                         )
-;; CHECK-NEXT:                        )
-;; CHECK-NEXT:                       )
-;; CHECK-NEXT:                      )
-;; CHECK-NEXT:                     )
-;; CHECK-NEXT:                    )
-;; CHECK-NEXT:                   )
-;; CHECK-NEXT:                  )
-;; CHECK-NEXT:                 )
-;; CHECK-NEXT:                )
-;; CHECK-NEXT:               )
-;; CHECK-NEXT:              )
-;; CHECK-NEXT:             )
-;; CHECK-NEXT:            )
-;; CHECK-NEXT:            (br $label$0)
-;; CHECK-NEXT:           )
-;; CHECK-NEXT:          )
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:        )
-;; CHECK-NEXT:        (v128.store offset=22 align=1
-;; CHECK-NEXT:         (i64.and
-;; CHECK-NEXT:          (local.get $12)
-;; CHECK-NEXT:          (i64.const 15)
-;; CHECK-NEXT:         )
-;; CHECK-NEXT:         (v128.const i32x4 0x20000001 0xffffffd5 0x00010000 0xfffffffd)
-;; CHECK-NEXT:        )
-;; CHECK-NEXT:       )
-;; CHECK-NEXT:      )
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT: )
-
-;; CHECK:      (func $func_13 (type $25) (result i64)
-;; CHECK-NEXT:  (local $0 i64)
-;; CHECK-NEXT:  (local $1 i64)
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (if
-;; CHECK-NEXT:    (i32.eqz
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:    (then
-;; CHECK-NEXT:     (global.set $hangLimit
-;; CHECK-NEXT:      (i32.const 100)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (unreachable)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (global.set $hangLimit
-;; CHECK-NEXT:    (i32.sub
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:     (i32.const 1)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT:  (i64.load16_u offset=22
-;; CHECK-NEXT:   (i64.load16_s offset=22 align=1
-;; CHECK-NEXT:    (i64.and
-;; CHECK-NEXT:     (local.tee $0
-;; CHECK-NEXT:      (local.get $1)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (i64.const 15)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT: )
-
-;; CHECK:      (func $func_14 (type $26) (param $0 i64) (param $1 (ref null $0)) (param $2 f64) (param $3 i32) (result (ref $5))
-;; CHECK-NEXT:  (local $4 f32)
-;; CHECK-NEXT:  (local $5 (ref struct))
-;; CHECK-NEXT:  (local $6 (ref array))
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (if
-;; CHECK-NEXT:    (i32.eqz
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:    (then
-;; CHECK-NEXT:     (global.set $hangLimit
-;; CHECK-NEXT:      (i32.const 100)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (unreachable)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (global.set $hangLimit
-;; CHECK-NEXT:    (i32.sub
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:     (i32.const 1)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT:  (return
-;; CHECK-NEXT:   (struct.new $5
-;; CHECK-NEXT:    (local.get $3)
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT: )
-
-;; CHECK:      (func $func_14_invoker (type $0)
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (if
-;; CHECK-NEXT:    (i32.eqz
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:    (then
-;; CHECK-NEXT:     (global.set $hangLimit
-;; CHECK-NEXT:      (i32.const 100)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (unreachable)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (global.set $hangLimit
-;; CHECK-NEXT:    (i32.sub
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:     (i32.const 1)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (drop
-;; CHECK-NEXT:    (call $func_14
-;; CHECK-NEXT:     (i64.const -47)
-;; CHECK-NEXT:     (ref.null nofunc)
-;; CHECK-NEXT:     (f64.const 1.1754943508222875e-38)
-;; CHECK-NEXT:     (i32.const -87)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (drop
-;; CHECK-NEXT:    (call $func_14
-;; CHECK-NEXT:     (i64.const -19)
-;; CHECK-NEXT:     (ref.func $import)
-;; CHECK-NEXT:     (f64.const -2147483648)
-;; CHECK-NEXT:     (i32.const -124)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (drop
-;; CHECK-NEXT:    (call $func_14
-;; CHECK-NEXT:     (i64.const 51497)
-;; CHECK-NEXT:     (ref.func $func)
-;; CHECK-NEXT:     (f64.const -nan:0xfffffffffffbc)
-;; CHECK-NEXT:     (i32.const -128)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT: )
+;; We must see an import from the primary module
+;; XXX This does depend on random choices in the fuzzer. We do have many chances
+;;     to emit one such import, but if this turns out to be too unlikely, we
+;;     can remove this test and depend on the fuzzer.
+;; CHECK:      (import "primary" 
 
-;; CHECK:      (func $func_16 (type $27) (param $0 stringref) (result (ref $0))
-;; CHECK-NEXT:  (block
-;; CHECK-NEXT:   (if
-;; CHECK-NEXT:    (i32.eqz
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:    (then
-;; CHECK-NEXT:     (global.set $hangLimit
-;; CHECK-NEXT:      (i32.const 100)
-;; CHECK-NEXT:     )
-;; CHECK-NEXT:     (unreachable)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:   (global.set $hangLimit
-;; CHECK-NEXT:    (i32.sub
-;; CHECK-NEXT:     (global.get $hangLimit)
-;; CHECK-NEXT:     (i32.const 1)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT:  (block $label$0
-;; CHECK-NEXT:   (return
-;; CHECK-NEXT:    (ref.as_non_null
-;; CHECK-NEXT:     (ref.null nofunc)
-;; CHECK-NEXT:    )
-;; CHECK-NEXT:   )
-;; CHECK-NEXT:  )
-;; CHECK-NEXT: )
diff --git a/test/lit/fuzz-import.wast.import.wast b/test/lit/fuzz-import.wast.import.wast
index 51b3aed876b..87aef31ebdf 100644
--- a/test/lit/fuzz-import.wast.import.wast
+++ b/test/lit/fuzz-import.wast.import.wast
@@ -1,39 +1,1014 @@
-;; Use lots of functions so we end up importing at least some.
+;; Use lots of functions so we end up importing at least some. The large number
+;; is to ensure we emit such an import in the test with very high probability.
 (module
   (global $g i32 (i32.const 42))
 
   ;; A non-function export should not cause problems.
   (export "e-g" (global $g))
 
-  (func $a (export "e-a") (param i32)
-  )
-  (func $a1 (export "e-a1") (param i32)
-  )
-  (func $a2 (export "e-a2") (param i32)
-  )
-  (func $a3 (export "e-a3") (param i32)
-  )
-  (func $a4 (export "e-a4") (param i32)
-  )
-
-  (func $b (export "e-b") (result i32)
-   (i32.const 0)
-  )
-  (func $b1 (export "e-b1") (result i32)
-   (i32.const 1)
-  )
-  (func $b2 (export "e-b2") (result i32)
-   (i32.const 2)
-  )
-  (func $b3 (export "e-b3") (result i32)
-   (i32.const 3)
-  )
-  (func $b4 (export "e-b4") (result i32)
-   (i32.const 4)
-  )
-
   ;; A non-exported function should not cause a problem.
   (func $c
   )
-)
+
+  ;; The exports.
+  (func $a0 (export "e-0"))
+  (func $a1 (export "e-1"))
+  (func $a2 (export "e-2"))
+  (func $a3 (export "e-3"))
+  (func $a4 (export "e-4"))
+  (func $a5 (export "e-5"))
+  (func $a6 (export "e-6"))
+  (func $a7 (export "e-7"))
+  (func $a8 (export "e-8"))
+  (func $a9 (export "e-9"))
+  (func $a10 (export "e-10"))
+  (func $a11 (export "e-11"))
+  (func $a12 (export "e-12"))
+  (func $a13 (export "e-13"))
+  (func $a14 (export "e-14"))
+  (func $a15 (export "e-15"))
+  (func $a16 (export "e-16"))
+  (func $a17 (export "e-17"))
+  (func $a18 (export "e-18"))
+  (func $a19 (export "e-19"))
+  (func $a20 (export "e-20"))
+  (func $a21 (export "e-21"))
+  (func $a22 (export "e-22"))
+  (func $a23 (export "e-23"))
+  (func $a24 (export "e-24"))
+  (func $a25 (export "e-25"))
+  (func $a26 (export "e-26"))
+  (func $a27 (export "e-27"))
+  (func $a28 (export "e-28"))
+  (func $a29 (export "e-29"))
+  (func $a30 (export "e-30"))
+  (func $a31 (export "e-31"))
+  (func $a32 (export "e-32"))
+  (func $a33 (export "e-33"))
+  (func $a34 (export "e-34"))
+  (func $a35 (export "e-35"))
+  (func $a36 (export "e-36"))
+  (func $a37 (export "e-37"))
+  (func $a38 (export "e-38"))
+  (func $a39 (export "e-39"))
+  (func $a40 (export "e-40"))
+  (func $a41 (export "e-41"))
+  (func $a42 (export "e-42"))
+  (func $a43 (export "e-43"))
+  (func $a44 (export "e-44"))
+  (func $a45 (export "e-45"))
+  (func $a46 (export "e-46"))
+  (func $a47 (export "e-47"))
+  (func $a48 (export "e-48"))
+  (func $a49 (export "e-49"))
+  (func $a50 (export "e-50"))
+  (func $a51 (export "e-51"))
+  (func $a52 (export "e-52"))
+  (func $a53 (export "e-53"))
+  (func $a54 (export "e-54"))
+  (func $a55 (export "e-55"))
+  (func $a56 (export "e-56"))
+  (func $a57 (export "e-57"))
+  (func $a58 (export "e-58"))
+  (func $a59 (export "e-59"))
+  (func $a60 (export "e-60"))
+  (func $a61 (export "e-61"))
+  (func $a62 (export "e-62"))
+  (func $a63 (export "e-63"))
+  (func $a64 (export "e-64"))
+  (func $a65 (export "e-65"))
+  (func $a66 (export "e-66"))
+  (func $a67 (export "e-67"))
+  (func $a68 (export "e-68"))
+  (func $a69 (export "e-69"))
+  (func $a70 (export "e-70"))
+  (func $a71 (export "e-71"))
+  (func $a72 (export "e-72"))
+  (func $a73 (export "e-73"))
+  (func $a74 (export "e-74"))
+  (func $a75 (export "e-75"))
+  (func $a76 (export "e-76"))
+  (func $a77 (export "e-77"))
+  (func $a78 (export "e-78"))
+  (func $a79 (export "e-79"))
+  (func $a80 (export "e-80"))
+  (func $a81 (export "e-81"))
+  (func $a82 (export "e-82"))
+  (func $a83 (export "e-83"))
+  (func $a84 (export "e-84"))
+  (func $a85 (export "e-85"))
+  (func $a86 (export "e-86"))
+  (func $a87 (export "e-87"))
+  (func $a88 (export "e-88"))
+  (func $a89 (export "e-89"))
+  (func $a90 (export "e-90"))
+  (func $a91 (export "e-91"))
+  (func $a92 (export "e-92"))
+  (func $a93 (export "e-93"))
+  (func $a94 (export "e-94"))
+  (func $a95 (export "e-95"))
+  (func $a96 (export "e-96"))
+  (func $a97 (export "e-97"))
+  (func $a98 (export "e-98"))
+  (func $a99 (export "e-99"))
+  (func $a100 (export "e-100"))
+  (func $a101 (export "e-101"))
+  (func $a102 (export "e-102"))
+  (func $a103 (export "e-103"))
+  (func $a104 (export "e-104"))
+  (func $a105 (export "e-105"))
+  (func $a106 (export "e-106"))
+  (func $a107 (export "e-107"))
+  (func $a108 (export "e-108"))
+  (func $a109 (export "e-109"))
+  (func $a110 (export "e-110"))
+  (func $a111 (export "e-111"))
+  (func $a112 (export "e-112"))
+  (func $a113 (export "e-113"))
+  (func $a114 (export "e-114"))
+  (func $a115 (export "e-115"))
+  (func $a116 (export "e-116"))
+  (func $a117 (export "e-117"))
+  (func $a118 (export "e-118"))
+  (func $a119 (export "e-119"))
+  (func $a120 (export "e-120"))
+  (func $a121 (export "e-121"))
+  (func $a122 (export "e-122"))
+  (func $a123 (export "e-123"))
+  (func $a124 (export "e-124"))
+  (func $a125 (export "e-125"))
+  (func $a126 (export "e-126"))
+  (func $a127 (export "e-127"))
+  (func $a128 (export "e-128"))
+  (func $a129 (export "e-129"))
+  (func $a130 (export "e-130"))
+  (func $a131 (export "e-131"))
+  (func $a132 (export "e-132"))
+  (func $a133 (export "e-133"))
+  (func $a134 (export "e-134"))
+  (func $a135 (export "e-135"))
+  (func $a136 (export "e-136"))
+  (func $a137 (export "e-137"))
+  (func $a138 (export "e-138"))
+  (func $a139 (export "e-139"))
+  (func $a140 (export "e-140"))
+  (func $a141 (export "e-141"))
+  (func $a142 (export "e-142"))
+  (func $a143 (export "e-143"))
+  (func $a144 (export "e-144"))
+  (func $a145 (export "e-145"))
+  (func $a146 (export "e-146"))
+  (func $a147 (export "e-147"))
+  (func $a148 (export "e-148"))
+  (func $a149 (export "e-149"))
+  (func $a150 (export "e-150"))
+  (func $a151 (export "e-151"))
+  (func $a152 (export "e-152"))
+  (func $a153 (export "e-153"))
+  (func $a154 (export "e-154"))
+  (func $a155 (export "e-155"))
+  (func $a156 (export "e-156"))
+  (func $a157 (export "e-157"))
+  (func $a158 (export "e-158"))
+  (func $a159 (export "e-159"))
+  (func $a160 (export "e-160"))
+  (func $a161 (export "e-161"))
+  (func $a162 (export "e-162"))
+  (func $a163 (export "e-163"))
+  (func $a164 (export "e-164"))
+  (func $a165 (export "e-165"))
+  (func $a166 (export "e-166"))
+  (func $a167 (export "e-167"))
+  (func $a168 (export "e-168"))
+  (func $a169 (export "e-169"))
+  (func $a170 (export "e-170"))
+  (func $a171 (export "e-171"))
+  (func $a172 (export "e-172"))
+  (func $a173 (export "e-173"))
+  (func $a174 (export "e-174"))
+  (func $a175 (export "e-175"))
+  (func $a176 (export "e-176"))
+  (func $a177 (export "e-177"))
+  (func $a178 (export "e-178"))
+  (func $a179 (export "e-179"))
+  (func $a180 (export "e-180"))
+  (func $a181 (export "e-181"))
+  (func $a182 (export "e-182"))
+  (func $a183 (export "e-183"))
+  (func $a184 (export "e-184"))
+  (func $a185 (export "e-185"))
+  (func $a186 (export "e-186"))
+  (func $a187 (export "e-187"))
+  (func $a188 (export "e-188"))
+  (func $a189 (export "e-189"))
+  (func $a190 (export "e-190"))
+  (func $a191 (export "e-191"))
+  (func $a192 (export "e-192"))
+  (func $a193 (export "e-193"))
+  (func $a194 (export "e-194"))
+  (func $a195 (export "e-195"))
+  (func $a196 (export "e-196"))
+  (func $a197 (export "e-197"))
+  (func $a198 (export "e-198"))
+  (func $a199 (export "e-199"))
+  (func $a200 (export "e-200"))
+  (func $a201 (export "e-201"))
+  (func $a202 (export "e-202"))
+  (func $a203 (export "e-203"))
+  (func $a204 (export "e-204"))
+  (func $a205 (export "e-205"))
+  (func $a206 (export "e-206"))
+  (func $a207 (export "e-207"))
+  (func $a208 (export "e-208"))
+  (func $a209 (export "e-209"))
+  (func $a210 (export "e-210"))
+  (func $a211 (export "e-211"))
+  (func $a212 (export "e-212"))
+  (func $a213 (export "e-213"))
+  (func $a214 (export "e-214"))
+  (func $a215 (export "e-215"))
+  (func $a216 (export "e-216"))
+  (func $a217 (export "e-217"))
+  (func $a218 (export "e-218"))
+  (func $a219 (export "e-219"))
+  (func $a220 (export "e-220"))
+  (func $a221 (export "e-221"))
+  (func $a222 (export "e-222"))
+  (func $a223 (export "e-223"))
+  (func $a224 (export "e-224"))
+  (func $a225 (export "e-225"))
+  (func $a226 (export "e-226"))
+  (func $a227 (export "e-227"))
+  (func $a228 (export "e-228"))
+  (func $a229 (export "e-229"))
+  (func $a230 (export "e-230"))
+  (func $a231 (export "e-231"))
+  (func $a232 (export "e-232"))
+  (func $a233 (export "e-233"))
+  (func $a234 (export "e-234"))
+  (func $a235 (export "e-235"))
+  (func $a236 (export "e-236"))
+  (func $a237 (export "e-237"))
+  (func $a238 (export "e-238"))
+  (func $a239 (export "e-239"))
+  (func $a240 (export "e-240"))
+  (func $a241 (export "e-241"))
+  (func $a242 (export "e-242"))
+  (func $a243 (export "e-243"))
+  (func $a244 (export "e-244"))
+  (func $a245 (export "e-245"))
+  (func $a246 (export "e-246"))
+  (func $a247 (export "e-247"))
+  (func $a248 (export "e-248"))
+  (func $a249 (export "e-249"))
+  (func $a250 (export "e-250"))
+  (func $a251 (export "e-251"))
+  (func $a252 (export "e-252"))
+  (func $a253 (export "e-253"))
+  (func $a254 (export "e-254"))
+  (func $a255 (export "e-255"))
+  (func $a256 (export "e-256"))
+  (func $a257 (export "e-257"))
+  (func $a258 (export "e-258"))
+  (func $a259 (export "e-259"))
+  (func $a260 (export "e-260"))
+  (func $a261 (export "e-261"))
+  (func $a262 (export "e-262"))
+  (func $a263 (export "e-263"))
+  (func $a264 (export "e-264"))
+  (func $a265 (export "e-265"))
+  (func $a266 (export "e-266"))
+  (func $a267 (export "e-267"))
+  (func $a268 (export "e-268"))
+  (func $a269 (export "e-269"))
+  (func $a270 (export "e-270"))
+  (func $a271 (export "e-271"))
+  (func $a272 (export "e-272"))
+  (func $a273 (export "e-273"))
+  (func $a274 (export "e-274"))
+  (func $a275 (export "e-275"))
+  (func $a276 (export "e-276"))
+  (func $a277 (export "e-277"))
+  (func $a278 (export "e-278"))
+  (func $a279 (export "e-279"))
+  (func $a280 (export "e-280"))
+  (func $a281 (export "e-281"))
+  (func $a282 (export "e-282"))
+  (func $a283 (export "e-283"))
+  (func $a284 (export "e-284"))
+  (func $a285 (export "e-285"))
+  (func $a286 (export "e-286"))
+  (func $a287 (export "e-287"))
+  (func $a288 (export "e-288"))
+  (func $a289 (export "e-289"))
+  (func $a290 (export "e-290"))
+  (func $a291 (export "e-291"))
+  (func $a292 (export "e-292"))
+  (func $a293 (export "e-293"))
+  (func $a294 (export "e-294"))
+  (func $a295 (export "e-295"))
+  (func $a296 (export "e-296"))
+  (func $a297 (export "e-297"))
+  (func $a298 (export "e-298"))
+  (func $a299 (export "e-299"))
+  (func $a300 (export "e-300"))
+  (func $a301 (export "e-301"))
+  (func $a302 (export "e-302"))
+  (func $a303 (export "e-303"))
+  (func $a304 (export "e-304"))
+  (func $a305 (export "e-305"))
+  (func $a306 (export "e-306"))
+  (func $a307 (export "e-307"))
+  (func $a308 (export "e-308"))
+  (func $a309 (export "e-309"))
+  (func $a310 (export "e-310"))
+  (func $a311 (export "e-311"))
+  (func $a312 (export "e-312"))
+  (func $a313 (export "e-313"))
+  (func $a314 (export "e-314"))
+  (func $a315 (export "e-315"))
+  (func $a316 (export "e-316"))
+  (func $a317 (export "e-317"))
+  (func $a318 (export "e-318"))
+  (func $a319 (export "e-319"))
+  (func $a320 (export "e-320"))
+  (func $a321 (export "e-321"))
+  (func $a322 (export "e-322"))
+  (func $a323 (export "e-323"))
+  (func $a324 (export "e-324"))
+  (func $a325 (export "e-325"))
+  (func $a326 (export "e-326"))
+  (func $a327 (export "e-327"))
+  (func $a328 (export "e-328"))
+  (func $a329 (export "e-329"))
+  (func $a330 (export "e-330"))
+  (func $a331 (export "e-331"))
+  (func $a332 (export "e-332"))
+  (func $a333 (export "e-333"))
+  (func $a334 (export "e-334"))
+  (func $a335 (export "e-335"))
+  (func $a336 (export "e-336"))
+  (func $a337 (export "e-337"))
+  (func $a338 (export "e-338"))
+  (func $a339 (export "e-339"))
+  (func $a340 (export "e-340"))
+  (func $a341 (export "e-341"))
+  (func $a342 (export "e-342"))
+  (func $a343 (export "e-343"))
+  (func $a344 (export "e-344"))
+  (func $a345 (export "e-345"))
+  (func $a346 (export "e-346"))
+  (func $a347 (export "e-347"))
+  (func $a348 (export "e-348"))
+  (func $a349 (export "e-349"))
+  (func $a350 (export "e-350"))
+  (func $a351 (export "e-351"))
+  (func $a352 (export "e-352"))
+  (func $a353 (export "e-353"))
+  (func $a354 (export "e-354"))
+  (func $a355 (export "e-355"))
+  (func $a356 (export "e-356"))
+  (func $a357 (export "e-357"))
+  (func $a358 (export "e-358"))
+  (func $a359 (export "e-359"))
+  (func $a360 (export "e-360"))
+  (func $a361 (export "e-361"))
+  (func $a362 (export "e-362"))
+  (func $a363 (export "e-363"))
+  (func $a364 (export "e-364"))
+  (func $a365 (export "e-365"))
+  (func $a366 (export "e-366"))
+  (func $a367 (export "e-367"))
+  (func $a368 (export "e-368"))
+  (func $a369 (export "e-369"))
+  (func $a370 (export "e-370"))
+  (func $a371 (export "e-371"))
+  (func $a372 (export "e-372"))
+  (func $a373 (export "e-373"))
+  (func $a374 (export "e-374"))
+  (func $a375 (export "e-375"))
+  (func $a376 (export "e-376"))
+  (func $a377 (export "e-377"))
+  (func $a378 (export "e-378"))
+  (func $a379 (export "e-379"))
+  (func $a380 (export "e-380"))
+  (func $a381 (export "e-381"))
+  (func $a382 (export "e-382"))
+  (func $a383 (export "e-383"))
+  (func $a384 (export "e-384"))
+  (func $a385 (export "e-385"))
+  (func $a386 (export "e-386"))
+  (func $a387 (export "e-387"))
+  (func $a388 (export "e-388"))
+  (func $a389 (export "e-389"))
+  (func $a390 (export "e-390"))
+  (func $a391 (export "e-391"))
+  (func $a392 (export "e-392"))
+  (func $a393 (export "e-393"))
+  (func $a394 (export "e-394"))
+  (func $a395 (export "e-395"))
+  (func $a396 (export "e-396"))
+  (func $a397 (export "e-397"))
+  (func $a398 (export "e-398"))
+  (func $a399 (export "e-399"))
+  (func $a400 (export "e-400"))
+  (func $a401 (export "e-401"))
+  (func $a402 (export "e-402"))
+  (func $a403 (export "e-403"))
+  (func $a404 (export "e-404"))
+  (func $a405 (export "e-405"))
+  (func $a406 (export "e-406"))
+  (func $a407 (export "e-407"))
+  (func $a408 (export "e-408"))
+  (func $a409 (export "e-409"))
+  (func $a410 (export "e-410"))
+  (func $a411 (export "e-411"))
+  (func $a412 (export "e-412"))
+  (func $a413 (export "e-413"))
+  (func $a414 (export "e-414"))
+  (func $a415 (export "e-415"))
+  (func $a416 (export "e-416"))
+  (func $a417 (export "e-417"))
+  (func $a418 (export "e-418"))
+  (func $a419 (export "e-419"))
+  (func $a420 (export "e-420"))
+  (func $a421 (export "e-421"))
+  (func $a422 (export "e-422"))
+  (func $a423 (export "e-423"))
+  (func $a424 (export "e-424"))
+  (func $a425 (export "e-425"))
+  (func $a426 (export "e-426"))
+  (func $a427 (export "e-427"))
+  (func $a428 (export "e-428"))
+  (func $a429 (export "e-429"))
+  (func $a430 (export "e-430"))
+  (func $a431 (export "e-431"))
+  (func $a432 (export "e-432"))
+  (func $a433 (export "e-433"))
+  (func $a434 (export "e-434"))
+  (func $a435 (export "e-435"))
+  (func $a436 (export "e-436"))
+  (func $a437 (export "e-437"))
+  (func $a438 (export "e-438"))
+  (func $a439 (export "e-439"))
+  (func $a440 (export "e-440"))
+  (func $a441 (export "e-441"))
+  (func $a442 (export "e-442"))
+  (func $a443 (export "e-443"))
+  (func $a444 (export "e-444"))
+  (func $a445 (export "e-445"))
+  (func $a446 (export "e-446"))
+  (func $a447 (export "e-447"))
+  (func $a448 (export "e-448"))
+  (func $a449 (export "e-449"))
+  (func $a450 (export "e-450"))
+  (func $a451 (export "e-451"))
+  (func $a452 (export "e-452"))
+  (func $a453 (export "e-453"))
+  (func $a454 (export "e-454"))
+  (func $a455 (export "e-455"))
+  (func $a456 (export "e-456"))
+  (func $a457 (export "e-457"))
+  (func $a458 (export "e-458"))
+  (func $a459 (export "e-459"))
+  (func $a460 (export "e-460"))
+  (func $a461 (export "e-461"))
+  (func $a462 (export "e-462"))
+  (func $a463 (export "e-463"))
+  (func $a464 (export "e-464"))
+  (func $a465 (export "e-465"))
+  (func $a466 (export "e-466"))
+  (func $a467 (export "e-467"))
+  (func $a468 (export "e-468"))
+  (func $a469 (export "e-469"))
+  (func $a470 (export "e-470"))
+  (func $a471 (export "e-471"))
+  (func $a472 (export "e-472"))
+  (func $a473 (export "e-473"))
+  (func $a474 (export "e-474"))
+  (func $a475 (export "e-475"))
+  (func $a476 (export "e-476"))
+  (func $a477 (export "e-477"))
+  (func $a478 (export "e-478"))
+  (func $a479 (export "e-479"))
+  (func $a480 (export "e-480"))
+  (func $a481 (export "e-481"))
+  (func $a482 (export "e-482"))
+  (func $a483 (export "e-483"))
+  (func $a484 (export "e-484"))
+  (func $a485 (export "e-485"))
+  (func $a486 (export "e-486"))
+  (func $a487 (export "e-487"))
+  (func $a488 (export "e-488"))
+  (func $a489 (export "e-489"))
+  (func $a490 (export "e-490"))
+  (func $a491 (export "e-491"))
+  (func $a492 (export "e-492"))
+  (func $a493 (export "e-493"))
+  (func $a494 (export "e-494"))
+  (func $a495 (export "e-495"))
+  (func $a496 (export "e-496"))
+  (func $a497 (export "e-497"))
+  (func $a498 (export "e-498"))
+  (func $a499 (export "e-499"))
+  (func $a500 (export "e-500"))
+  (func $a501 (export "e-501"))
+  (func $a502 (export "e-502"))
+  (func $a503 (export "e-503"))
+  (func $a504 (export "e-504"))
+  (func $a505 (export "e-505"))
+  (func $a506 (export "e-506"))
+  (func $a507 (export "e-507"))
+  (func $a508 (export "e-508"))
+  (func $a509 (export "e-509"))
+  (func $a510 (export "e-510"))
+  (func $a511 (export "e-511"))
+  (func $a512 (export "e-512"))
+  (func $a513 (export "e-513"))
+  (func $a514 (export "e-514"))
+  (func $a515 (export "e-515"))
+  (func $a516 (export "e-516"))
+  (func $a517 (export "e-517"))
+  (func $a518 (export "e-518"))
+  (func $a519 (export "e-519"))
+  (func $a520 (export "e-520"))
+  (func $a521 (export "e-521"))
+  (func $a522 (export "e-522"))
+  (func $a523 (export "e-523"))
+  (func $a524 (export "e-524"))
+  (func $a525 (export "e-525"))
+  (func $a526 (export "e-526"))
+  (func $a527 (export "e-527"))
+  (func $a528 (export "e-528"))
+  (func $a529 (export "e-529"))
+  (func $a530 (export "e-530"))
+  (func $a531 (export "e-531"))
+  (func $a532 (export "e-532"))
+  (func $a533 (export "e-533"))
+  (func $a534 (export "e-534"))
+  (func $a535 (export "e-535"))
+  (func $a536 (export "e-536"))
+  (func $a537 (export "e-537"))
+  (func $a538 (export "e-538"))
+  (func $a539 (export "e-539"))
+  (func $a540 (export "e-540"))
+  (func $a541 (export "e-541"))
+  (func $a542 (export "e-542"))
+  (func $a543 (export "e-543"))
+  (func $a544 (export "e-544"))
+  (func $a545 (export "e-545"))
+  (func $a546 (export "e-546"))
+  (func $a547 (export "e-547"))
+  (func $a548 (export "e-548"))
+  (func $a549 (export "e-549"))
+  (func $a550 (export "e-550"))
+  (func $a551 (export "e-551"))
+  (func $a552 (export "e-552"))
+  (func $a553 (export "e-553"))
+  (func $a554 (export "e-554"))
+  (func $a555 (export "e-555"))
+  (func $a556 (export "e-556"))
+  (func $a557 (export "e-557"))
+  (func $a558 (export "e-558"))
+  (func $a559 (export "e-559"))
+  (func $a560 (export "e-560"))
+  (func $a561 (export "e-561"))
+  (func $a562 (export "e-562"))
+  (func $a563 (export "e-563"))
+  (func $a564 (export "e-564"))
+  (func $a565 (export "e-565"))
+  (func $a566 (export "e-566"))
+  (func $a567 (export "e-567"))
+  (func $a568 (export "e-568"))
+  (func $a569 (export "e-569"))
+  (func $a570 (export "e-570"))
+  (func $a571 (export "e-571"))
+  (func $a572 (export "e-572"))
+  (func $a573 (export "e-573"))
+  (func $a574 (export "e-574"))
+  (func $a575 (export "e-575"))
+  (func $a576 (export "e-576"))
+  (func $a577 (export "e-577"))
+  (func $a578 (export "e-578"))
+  (func $a579 (export "e-579"))
+  (func $a580 (export "e-580"))
+  (func $a581 (export "e-581"))
+  (func $a582 (export "e-582"))
+  (func $a583 (export "e-583"))
+  (func $a584 (export "e-584"))
+  (func $a585 (export "e-585"))
+  (func $a586 (export "e-586"))
+  (func $a587 (export "e-587"))
+  (func $a588 (export "e-588"))
+  (func $a589 (export "e-589"))
+  (func $a590 (export "e-590"))
+  (func $a591 (export "e-591"))
+  (func $a592 (export "e-592"))
+  (func $a593 (export "e-593"))
+  (func $a594 (export "e-594"))
+  (func $a595 (export "e-595"))
+  (func $a596 (export "e-596"))
+  (func $a597 (export "e-597"))
+  (func $a598 (export "e-598"))
+  (func $a599 (export "e-599"))
+  (func $a600 (export "e-600"))
+  (func $a601 (export "e-601"))
+  (func $a602 (export "e-602"))
+  (func $a603 (export "e-603"))
+  (func $a604 (export "e-604"))
+  (func $a605 (export "e-605"))
+  (func $a606 (export "e-606"))
+  (func $a607 (export "e-607"))
+  (func $a608 (export "e-608"))
+  (func $a609 (export "e-609"))
+  (func $a610 (export "e-610"))
+  (func $a611 (export "e-611"))
+  (func $a612 (export "e-612"))
+  (func $a613 (export "e-613"))
+  (func $a614 (export "e-614"))
+  (func $a615 (export "e-615"))
+  (func $a616 (export "e-616"))
+  (func $a617 (export "e-617"))
+  (func $a618 (export "e-618"))
+  (func $a619 (export "e-619"))
+  (func $a620 (export "e-620"))
+  (func $a621 (export "e-621"))
+  (func $a622 (export "e-622"))
+  (func $a623 (export "e-623"))
+  (func $a624 (export "e-624"))
+  (func $a625 (export "e-625"))
+  (func $a626 (export "e-626"))
+  (func $a627 (export "e-627"))
+  (func $a628 (export "e-628"))
+  (func $a629 (export "e-629"))
+  (func $a630 (export "e-630"))
+  (func $a631 (export "e-631"))
+  (func $a632 (export "e-632"))
+  (func $a633 (export "e-633"))
+  (func $a634 (export "e-634"))
+  (func $a635 (export "e-635"))
+  (func $a636 (export "e-636"))
+  (func $a637 (export "e-637"))
+  (func $a638 (export "e-638"))
+  (func $a639 (export "e-639"))
+  (func $a640 (export "e-640"))
+  (func $a641 (export "e-641"))
+  (func $a642 (export "e-642"))
+  (func $a643 (export "e-643"))
+  (func $a644 (export "e-644"))
+  (func $a645 (export "e-645"))
+  (func $a646 (export "e-646"))
+  (func $a647 (export "e-647"))
+  (func $a648 (export "e-648"))
+  (func $a649 (export "e-649"))
+  (func $a650 (export "e-650"))
+  (func $a651 (export "e-651"))
+  (func $a652 (export "e-652"))
+  (func $a653 (export "e-653"))
+  (func $a654 (export "e-654"))
+  (func $a655 (export "e-655"))
+  (func $a656 (export "e-656"))
+  (func $a657 (export "e-657"))
+  (func $a658 (export "e-658"))
+  (func $a659 (export "e-659"))
+  (func $a660 (export "e-660"))
+  (func $a661 (export "e-661"))
+  (func $a662 (export "e-662"))
+  (func $a663 (export "e-663"))
+  (func $a664 (export "e-664"))
+  (func $a665 (export "e-665"))
+  (func $a666 (export "e-666"))
+  (func $a667 (export "e-667"))
+  (func $a668 (export "e-668"))
+  (func $a669 (export "e-669"))
+  (func $a670 (export "e-670"))
+  (func $a671 (export "e-671"))
+  (func $a672 (export "e-672"))
+  (func $a673 (export "e-673"))
+  (func $a674 (export "e-674"))
+  (func $a675 (export "e-675"))
+  (func $a676 (export "e-676"))
+  (func $a677 (export "e-677"))
+  (func $a678 (export "e-678"))
+  (func $a679 (export "e-679"))
+  (func $a680 (export "e-680"))
+  (func $a681 (export "e-681"))
+  (func $a682 (export "e-682"))
+  (func $a683 (export "e-683"))
+  (func $a684 (export "e-684"))
+  (func $a685 (export "e-685"))
+  (func $a686 (export "e-686"))
+  (func $a687 (export "e-687"))
+  (func $a688 (export "e-688"))
+  (func $a689 (export "e-689"))
+  (func $a690 (export "e-690"))
+  (func $a691 (export "e-691"))
+  (func $a692 (export "e-692"))
+  (func $a693 (export "e-693"))
+  (func $a694 (export "e-694"))
+  (func $a695 (export "e-695"))
+  (func $a696 (export "e-696"))
+  (func $a697 (export "e-697"))
+  (func $a698 (export "e-698"))
+  (func $a699 (export "e-699"))
+  (func $a700 (export "e-700"))
+  (func $a701 (export "e-701"))
+  (func $a702 (export "e-702"))
+  (func $a703 (export "e-703"))
+  (func $a704 (export "e-704"))
+  (func $a705 (export "e-705"))
+  (func $a706 (export "e-706"))
+  (func $a707 (export "e-707"))
+  (func $a708 (export "e-708"))
+  (func $a709 (export "e-709"))
+  (func $a710 (export "e-710"))
+  (func $a711 (export "e-711"))
+  (func $a712 (export "e-712"))
+  (func $a713 (export "e-713"))
+  (func $a714 (export "e-714"))
+  (func $a715 (export "e-715"))
+  (func $a716 (export "e-716"))
+  (func $a717 (export "e-717"))
+  (func $a718 (export "e-718"))
+  (func $a719 (export "e-719"))
+  (func $a720 (export "e-720"))
+  (func $a721 (export "e-721"))
+  (func $a722 (export "e-722"))
+  (func $a723 (export "e-723"))
+  (func $a724 (export "e-724"))
+  (func $a725 (export "e-725"))
+  (func $a726 (export "e-726"))
+  (func $a727 (export "e-727"))
+  (func $a728 (export "e-728"))
+  (func $a729 (export "e-729"))
+  (func $a730 (export "e-730"))
+  (func $a731 (export "e-731"))
+  (func $a732 (export "e-732"))
+  (func $a733 (export "e-733"))
+  (func $a734 (export "e-734"))
+  (func $a735 (export "e-735"))
+  (func $a736 (export "e-736"))
+  (func $a737 (export "e-737"))
+  (func $a738 (export "e-738"))
+  (func $a739 (export "e-739"))
+  (func $a740 (export "e-740"))
+  (func $a741 (export "e-741"))
+  (func $a742 (export "e-742"))
+  (func $a743 (export "e-743"))
+  (func $a744 (export "e-744"))
+  (func $a745 (export "e-745"))
+  (func $a746 (export "e-746"))
+  (func $a747 (export "e-747"))
+  (func $a748 (export "e-748"))
+  (func $a749 (export "e-749"))
+  (func $a750 (export "e-750"))
+  (func $a751 (export "e-751"))
+  (func $a752 (export "e-752"))
+  (func $a753 (export "e-753"))
+  (func $a754 (export "e-754"))
+  (func $a755 (export "e-755"))
+  (func $a756 (export "e-756"))
+  (func $a757 (export "e-757"))
+  (func $a758 (export "e-758"))
+  (func $a759 (export "e-759"))
+  (func $a760 (export "e-760"))
+  (func $a761 (export "e-761"))
+  (func $a762 (export "e-762"))
+  (func $a763 (export "e-763"))
+  (func $a764 (export "e-764"))
+  (func $a765 (export "e-765"))
+  (func $a766 (export "e-766"))
+  (func $a767 (export "e-767"))
+  (func $a768 (export "e-768"))
+  (func $a769 (export "e-769"))
+  (func $a770 (export "e-770"))
+  (func $a771 (export "e-771"))
+  (func $a772 (export "e-772"))
+  (func $a773 (export "e-773"))
+  (func $a774 (export "e-774"))
+  (func $a775 (export "e-775"))
+  (func $a776 (export "e-776"))
+  (func $a777 (export "e-777"))
+  (func $a778 (export "e-778"))
+  (func $a779 (export "e-779"))
+  (func $a780 (export "e-780"))
+  (func $a781 (export "e-781"))
+  (func $a782 (export "e-782"))
+  (func $a783 (export "e-783"))
+  (func $a784 (export "e-784"))
+  (func $a785 (export "e-785"))
+  (func $a786 (export "e-786"))
+  (func $a787 (export "e-787"))
+  (func $a788 (export "e-788"))
+  (func $a789 (export "e-789"))
+  (func $a790 (export "e-790"))
+  (func $a791 (export "e-791"))
+  (func $a792 (export "e-792"))
+  (func $a793 (export "e-793"))
+  (func $a794 (export "e-794"))
+  (func $a795 (export "e-795"))
+  (func $a796 (export "e-796"))
+  (func $a797 (export "e-797"))
+  (func $a798 (export "e-798"))
+  (func $a799 (export "e-799"))
+  (func $a800 (export "e-800"))
+  (func $a801 (export "e-801"))
+  (func $a802 (export "e-802"))
+  (func $a803 (export "e-803"))
+  (func $a804 (export "e-804"))
+  (func $a805 (export "e-805"))
+  (func $a806 (export "e-806"))
+  (func $a807 (export "e-807"))
+  (func $a808 (export "e-808"))
+  (func $a809 (export "e-809"))
+  (func $a810 (export "e-810"))
+  (func $a811 (export "e-811"))
+  (func $a812 (export "e-812"))
+  (func $a813 (export "e-813"))
+  (func $a814 (export "e-814"))
+  (func $a815 (export "e-815"))
+  (func $a816 (export "e-816"))
+  (func $a817 (export "e-817"))
+  (func $a818 (export "e-818"))
+  (func $a819 (export "e-819"))
+  (func $a820 (export "e-820"))
+  (func $a821 (export "e-821"))
+  (func $a822 (export "e-822"))
+  (func $a823 (export "e-823"))
+  (func $a824 (export "e-824"))
+  (func $a825 (export "e-825"))
+  (func $a826 (export "e-826"))
+  (func $a827 (export "e-827"))
+  (func $a828 (export "e-828"))
+  (func $a829 (export "e-829"))
+  (func $a830 (export "e-830"))
+  (func $a831 (export "e-831"))
+  (func $a832 (export "e-832"))
+  (func $a833 (export "e-833"))
+  (func $a834 (export "e-834"))
+  (func $a835 (export "e-835"))
+  (func $a836 (export "e-836"))
+  (func $a837 (export "e-837"))
+  (func $a838 (export "e-838"))
+  (func $a839 (export "e-839"))
+  (func $a840 (export "e-840"))
+  (func $a841 (export "e-841"))
+  (func $a842 (export "e-842"))
+  (func $a843 (export "e-843"))
+  (func $a844 (export "e-844"))
+  (func $a845 (export "e-845"))
+  (func $a846 (export "e-846"))
+  (func $a847 (export "e-847"))
+  (func $a848 (export "e-848"))
+  (func $a849 (export "e-849"))
+  (func $a850 (export "e-850"))
+  (func $a851 (export "e-851"))
+  (func $a852 (export "e-852"))
+  (func $a853 (export "e-853"))
+  (func $a854 (export "e-854"))
+  (func $a855 (export "e-855"))
+  (func $a856 (export "e-856"))
+  (func $a857 (export "e-857"))
+  (func $a858 (export "e-858"))
+  (func $a859 (export "e-859"))
+  (func $a860 (export "e-860"))
+  (func $a861 (export "e-861"))
+  (func $a862 (export "e-862"))
+  (func $a863 (export "e-863"))
+  (func $a864 (export "e-864"))
+  (func $a865 (export "e-865"))
+  (func $a866 (export "e-866"))
+  (func $a867 (export "e-867"))
+  (func $a868 (export "e-868"))
+  (func $a869 (export "e-869"))
+  (func $a870 (export "e-870"))
+  (func $a871 (export "e-871"))
+  (func $a872 (export "e-872"))
+  (func $a873 (export "e-873"))
+  (func $a874 (export "e-874"))
+  (func $a875 (export "e-875"))
+  (func $a876 (export "e-876"))
+  (func $a877 (export "e-877"))
+  (func $a878 (export "e-878"))
+  (func $a879 (export "e-879"))
+  (func $a880 (export "e-880"))
+  (func $a881 (export "e-881"))
+  (func $a882 (export "e-882"))
+  (func $a883 (export "e-883"))
+  (func $a884 (export "e-884"))
+  (func $a885 (export "e-885"))
+  (func $a886 (export "e-886"))
+  (func $a887 (export "e-887"))
+  (func $a888 (export "e-888"))
+  (func $a889 (export "e-889"))
+  (func $a890 (export "e-890"))
+  (func $a891 (export "e-891"))
+  (func $a892 (export "e-892"))
+  (func $a893 (export "e-893"))
+  (func $a894 (export "e-894"))
+  (func $a895 (export "e-895"))
+  (func $a896 (export "e-896"))
+  (func $a897 (export "e-897"))
+  (func $a898 (export "e-898"))
+  (func $a899 (export "e-899"))
+  (func $a900 (export "e-900"))
+  (func $a901 (export "e-901"))
+  (func $a902 (export "e-902"))
+  (func $a903 (export "e-903"))
+  (func $a904 (export "e-904"))
+  (func $a905 (export "e-905"))
+  (func $a906 (export "e-906"))
+  (func $a907 (export "e-907"))
+  (func $a908 (export "e-908"))
+  (func $a909 (export "e-909"))
+  (func $a910 (export "e-910"))
+  (func $a911 (export "e-911"))
+  (func $a912 (export "e-912"))
+  (func $a913 (export "e-913"))
+  (func $a914 (export "e-914"))
+  (func $a915 (export "e-915"))
+  (func $a916 (export "e-916"))
+  (func $a917 (export "e-917"))
+  (func $a918 (export "e-918"))
+  (func $a919 (export "e-919"))
+  (func $a920 (export "e-920"))
+  (func $a921 (export "e-921"))
+  (func $a922 (export "e-922"))
+  (func $a923 (export "e-923"))
+  (func $a924 (export "e-924"))
+  (func $a925 (export "e-925"))
+  (func $a926 (export "e-926"))
+  (func $a927 (export "e-927"))
+  (func $a928 (export "e-928"))
+  (func $a929 (export "e-929"))
+  (func $a930 (export "e-930"))
+  (func $a931 (export "e-931"))
+  (func $a932 (export "e-932"))
+  (func $a933 (export "e-933"))
+  (func $a934 (export "e-934"))
+  (func $a935 (export "e-935"))
+  (func $a936 (export "e-936"))
+  (func $a937 (export "e-937"))
+  (func $a938 (export "e-938"))
+  (func $a939 (export "e-939"))
+  (func $a940 (export "e-940"))
+  (func $a941 (export "e-941"))
+  (func $a942 (export "e-942"))
+  (func $a943 (export "e-943"))
+  (func $a944 (export "e-944"))
+  (func $a945 (export "e-945"))
+  (func $a946 (export "e-946"))
+  (func $a947 (export "e-947"))
+  (func $a948 (export "e-948"))
+  (func $a949 (export "e-949"))
+  (func $a950 (export "e-950"))
+  (func $a951 (export "e-951"))
+  (func $a952 (export "e-952"))
+  (func $a953 (export "e-953"))
+  (func $a954 (export "e-954"))
+  (func $a955 (export "e-955"))
+  (func $a956 (export "e-956"))
+  (func $a957 (export "e-957"))
+  (func $a958 (export "e-958"))
+  (func $a959 (export "e-959"))
+  (func $a960 (export "e-960"))
+  (func $a961 (export "e-961"))
+  (func $a962 (export "e-962"))
+  (func $a963 (export "e-963"))
+  (func $a964 (export "e-964"))
+  (func $a965 (export "e-965"))
+  (func $a966 (export "e-966"))
+  (func $a967 (export "e-967"))
+  (func $a968 (export "e-968"))
+  (func $a969 (export "e-969"))
+  (func $a970 (export "e-970"))
+  (func $a971 (export "e-971"))
+  (func $a972 (export "e-972"))
+  (func $a973 (export "e-973"))
+  (func $a974 (export "e-974"))
+  (func $a975 (export "e-975"))
+  (func $a976 (export "e-976"))
+  (func $a977 (export "e-977"))
+  (func $a978 (export "e-978"))
+  (func $a979 (export "e-979"))
+  (func $a980 (export "e-980"))
+  (func $a981 (export "e-981"))
+  (func $a982 (export "e-982"))
+  (func $a983 (export "e-983"))
+  (func $a984 (export "e-984"))
+  (func $a985 (export "e-985"))
+  (func $a986 (export "e-986"))
+  (func $a987 (export "e-987"))
+  (func $a988 (export "e-988"))
+  (func $a989 (export "e-989"))
+  (func $a990 (export "e-990"))
+  (func $a991 (export "e-991"))
+  (func $a992 (export "e-992"))
+  (func $a993 (export "e-993"))
+  (func $a994 (export "e-994"))
+  (func $a995 (export "e-995"))
+  (func $a996 (export "e-996"))
+  (func $a997 (export "e-997"))
+  (func $a998 (export "e-998"))
+  (func $a999 (export "e-999")))
 

From 3ae249ef0451e376516ba6234ff4af23aa5c5096 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 11:27:21 -0700
Subject: [PATCH 12/42] go

---
 scripts/fuzz_opt.py           | 18 +++++-------------
 src/tools/fuzzing/fuzzing.cpp |  3 ++-
 2 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index d70b191fd98..7fbfa530e31 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1777,7 +1777,7 @@ def ensure(self):
 # anything. This is similar to Split(), but rather than split a wasm file into
 # two and link them at runtime, this starts with two separate wasm files.
 class Two(TestCaseHandler):
-    frequency = 0.2
+    frequency = 1 # 0.2
 
     def handle(self, wasm):
         # Generate a second wasm file, unless we were given one (useful during
@@ -1791,6 +1791,9 @@ def handle(self, wasm):
             second_input = abspath('second_input.dat')
             make_random_input(random_size(), second_input)
             args = [second_input, '-ttf', '-o', second_wasm]
+            # Most of the time, use the first wasm as an import to the second.
+            if random.random() < 0.5:
+                args += ['--fuzz-importz=' + wasm]
             run([in_bin('wasm-opt')] + args + GEN_ARGS + FEATURE_OPTS)
 
         # The binaryen interpreter only supports a single file, so we run them
@@ -1845,6 +1848,7 @@ def can_run_on_wasm(self, wasm):
         # mode. We also cannot run shared-everything code in d8 yet. We also
         # cannot compare if there are NaNs (as optimizations can lead to
         # different outputs).
+        # TODO: relax some of these
         if CLOSED_WORLD:
             return False
         if NANS:
@@ -2114,19 +2118,7 @@ def handle(self, wasm):
 
 # The global list of all test case handlers
 testcase_handlers = [
-    FuzzExec(),
-    CompareVMs(),
-    CheckDeterminism(),
-    Wasm2JS(),
-    TrapsNeverHappen(),
-    CtorEval(),
-    Merge(),
-    Split(),
-    RoundtripText(),
-    ClusterFuzz(),
     Two(),
-    PreserveImportsExports(),
-    BranchHintPreservation(),
 ]
 
 
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index ab621a54ca1..5c8c741ecc6 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -1170,6 +1170,7 @@ void TranslateToFuzzReader::useImportedModule() {
   }
 
   Module imported;
+  imported.features = FeatureSet::All;
   ModuleReader().read(*importedModule, imported);
 
   // Add some of the module's exported functions as imports, at a random rate.
@@ -1180,7 +1181,7 @@ void TranslateToFuzzReader::useImportedModule() {
     }
 
     auto* func = imported.getFunction(*exp->getInternalName());
-    auto name = Names::getValidFunctionName(wasm, func->name);
+    auto name = Names::getValidFunctionName(wasm, "primary_" + exp->name.toString());
     // We can import it as its own type, or any (declared) supertype.
     auto type = getSuperType(func->type);
     auto import = builder.makeFunction(name, type, {});

From c96682d5c8b14cc3788e392c73f95d53ecb54292 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 11:30:01 -0700
Subject: [PATCH 13/42] go

---
 scripts/fuzz_opt.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index 7fbfa530e31..fcb3cdfd148 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1793,7 +1793,7 @@ def handle(self, wasm):
             args = [second_input, '-ttf', '-o', second_wasm]
             # Most of the time, use the first wasm as an import to the second.
             if random.random() < 0.5:
-                args += ['--fuzz-importz=' + wasm]
+                args += ['--fuzz-import=' + wasm]
             run([in_bin('wasm-opt')] + args + GEN_ARGS + FEATURE_OPTS)
 
         # The binaryen interpreter only supports a single file, so we run them

From 05060c9ca76dddce43903f488cbfd4904883834e Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 11:43:53 -0700
Subject: [PATCH 14/42] go

---
 scripts/fuzz_opt.py   | 3 ++-
 scripts/fuzz_shell.js | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index fcb3cdfd148..093ec2faf3e 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -753,6 +753,7 @@ def __init__(self):
     # care about their relationship.
     def handle_pair(self, input, before_wasm, after_wasm, opts):
         self.handle(before_wasm)
+        print('\n')
         self.handle(after_wasm)
 
     def can_run_on_wasm(self, wasm):
@@ -1806,7 +1807,7 @@ def handle(self, wasm):
         # see that that behavior remains even after optimizations.
         output = run_d8_wasm(wasm, args=[second_wasm])
 
-        if output == IGNORE:
+        if output == IGNORE: # XXX check no 'primary' in error
             # There is no point to continue since we can't compare this output
             # to anything.
             return
diff --git a/scripts/fuzz_shell.js b/scripts/fuzz_shell.js
index 2e66c5cd6d3..bfdbd44e632 100644
--- a/scripts/fuzz_shell.js
+++ b/scripts/fuzz_shell.js
@@ -435,7 +435,7 @@ if (secondBinary) {
 // Compile and instantiate a wasm file. Receives the binary to build, and
 // whether it is the second one.
 function build(binary, isSecond) {
-  if (fuzzSplit && isSecond) {
+  if (isSecond) {
     assert(secondBinary);
     // Provide the primary module's exports to the secondary.
     imports['primary'] = exports;

From 33727e8e44257c413f229636af6268fd3ddd02bb Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 11:57:28 -0700
Subject: [PATCH 15/42] go

---
 scripts/fuzz_opt.py | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index 093ec2faf3e..81c834ddfac 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -602,6 +602,7 @@ def note_ignored_vm_run(reason, extra_text='', amount=1):
     ignored_vm_run_reasons[reason] += amount
 
 
+# Run a VM command, and filter out known issues.
 def run_vm(cmd):
     def filter_known_issues(output):
         known_issues = [
@@ -1807,7 +1808,7 @@ def handle(self, wasm):
         # see that that behavior remains even after optimizations.
         output = run_d8_wasm(wasm, args=[second_wasm])
 
-        if output == IGNORE: # XXX check no 'primary' in error
+        if output == IGNORE:
             # There is no point to continue since we can't compare this output
             # to anything.
             return
@@ -1816,6 +1817,20 @@ def handle(self, wasm):
             # We may fail to instantiate the modules for valid reasons, such as
             # an active segment being out of bounds. There is no point to
             # continue in such cases, as no exports are called.
+
+            # But, check 'primary' is not in the V8 error. That might indicate a
+            # problem in the imports of --fuzz-import. To do this, run the d8
+            # command directly, without the usual filtering of run_d8_wasm.
+            cmd = [shared.V8] + shared.V8_OPTS + get_v8_extra_flags() + [
+                get_fuzz_shell_js(),
+                '--',
+                wasm,
+                second_wasm
+            ]
+            out = run(cmd)
+            assert '"primary"' not in out, out
+
+            note_ignored_vm_run('Two instantiate error')
             return
 
         # Make sure that fuzz_shell.js actually executed all exports from both

From 1aff0c1cefa26993830bde16736c16d8e4a66f03 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 12:46:06 -0700
Subject: [PATCH 16/42] FIX.prune

---
 src/passes/LegalizeJSInterface.cpp            |  5 ++-
 .../legalize-and-prune-js-interface.wast      | 38 +++++++++++++++----
 2 files changed, 34 insertions(+), 9 deletions(-)

diff --git a/src/passes/LegalizeJSInterface.cpp b/src/passes/LegalizeJSInterface.cpp
index 327d28d76a4..2881a2e1623 100644
--- a/src/passes/LegalizeJSInterface.cpp
+++ b/src/passes/LegalizeJSInterface.cpp
@@ -391,9 +391,12 @@ struct LegalizeAndPruneJSInterface : public LegalizeJSInterface {
         Builder builder(*module);
         if (sig.results == Type::none) {
           func->body = builder.makeNop();
-        } else {
+        } else if (sig.results.isDefaultable()) {
           func->body =
             builder.makeConstantExpression(Literal::makeZeros(sig.results));
+        } else {
+          // We have nothing better than the trap here.
+          func->body = builder.makeUnreachable();
         }
       }
 
diff --git a/test/lit/passes/legalize-and-prune-js-interface.wast b/test/lit/passes/legalize-and-prune-js-interface.wast
index 0840ddbdd57..01b89d42912 100644
--- a/test/lit/passes/legalize-and-prune-js-interface.wast
+++ b/test/lit/passes/legalize-and-prune-js-interface.wast
@@ -14,6 +14,13 @@
 
   (import "env" "imported-v128-param-noresult" (func $imported-v128-param-noresult (param v128)))
 
+  ;; The results here include a nullable value, which we will emit a null for.
+  (import "env" "imported-v128-defaultable" (func $imported-v128-defaultable (result v128 anyref)))
+
+  ;; The results here include a non-nullable value, which will force us to emit
+  ;; an unreachable.
+  (import "env" "imported-v128-nondefaultable" (func $imported-v128-nondefaultable (result v128 (ref any))))
+
   ;; CHECK:      (type $0 (func (result v128)))
 
   ;; CHECK:      (type $1 (func (result i32 f64)))
@@ -22,17 +29,21 @@
 
   ;; CHECK:      (type $3 (func (param v128)))
 
-  ;; CHECK:      (type $4 (func))
+  ;; CHECK:      (type $4 (func (result v128 anyref)))
+
+  ;; CHECK:      (type $5 (func (result v128 (ref any))))
 
-  ;; CHECK:      (type $5 (func (result i32)))
+  ;; CHECK:      (type $6 (func))
 
-  ;; CHECK:      (type $6 (func (param i32 f64) (result i64)))
+  ;; CHECK:      (type $7 (func (result i32)))
 
-  ;; CHECK:      (type $7 (func (param i32 f64) (result i32)))
+  ;; CHECK:      (type $8 (func (param i32 f64) (result i64)))
 
-  ;; CHECK:      (import "env" "getTempRet0" (func $getTempRet0 (type $5) (result i32)))
+  ;; CHECK:      (type $9 (func (param i32 f64) (result i32)))
 
-  ;; CHECK:      (import "env" "imported-64" (func $legalimport$imported-64 (type $7) (param i32 f64) (result i32)))
+  ;; CHECK:      (import "env" "getTempRet0" (func $getTempRet0 (type $7) (result i32)))
+
+  ;; CHECK:      (import "env" "imported-64" (func $legalimport$imported-64 (type $9) (param i32 f64) (result i32)))
 
   ;; CHECK:      (func $imported-v128 (type $0) (result v128)
   ;; CHECK-NEXT:  (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
@@ -53,7 +64,18 @@
   ;; CHECK-NEXT:  (nop)
   ;; CHECK-NEXT: )
 
-  ;; CHECK:      (func $call-64 (type $4)
+  ;; CHECK:      (func $imported-v128-defaultable (type $4) (result v128 anyref)
+  ;; CHECK-NEXT:  (tuple.make 2
+  ;; CHECK-NEXT:   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+  ;; CHECK-NEXT:   (ref.null none)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $imported-v128-nondefaultable (type $5) (result v128 (ref any))
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $call-64 (type $6)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (call $legalfunc$imported-64
   ;; CHECK-NEXT:    (i32.const 0)
@@ -103,7 +125,7 @@
   )
 )
 
-;; CHECK:      (func $legalfunc$imported-64 (type $6) (param $0 i32) (param $1 f64) (result i64)
+;; CHECK:      (func $legalfunc$imported-64 (type $8) (param $0 i32) (param $1 f64) (result i64)
 ;; CHECK-NEXT:  (i64.or
 ;; CHECK-NEXT:   (i64.extend_i32_u
 ;; CHECK-NEXT:    (call $legalimport$imported-64

From 7e75c16559b3f457cf54b000e8b7b4f110c0104d Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 12:46:06 -0700
Subject: [PATCH 17/42] FIX.prune

---
 src/passes/LegalizeJSInterface.cpp            |  5 ++-
 .../legalize-and-prune-js-interface.wast      | 38 +++++++++++++++----
 2 files changed, 34 insertions(+), 9 deletions(-)

diff --git a/src/passes/LegalizeJSInterface.cpp b/src/passes/LegalizeJSInterface.cpp
index 327d28d76a4..2881a2e1623 100644
--- a/src/passes/LegalizeJSInterface.cpp
+++ b/src/passes/LegalizeJSInterface.cpp
@@ -391,9 +391,12 @@ struct LegalizeAndPruneJSInterface : public LegalizeJSInterface {
         Builder builder(*module);
         if (sig.results == Type::none) {
           func->body = builder.makeNop();
-        } else {
+        } else if (sig.results.isDefaultable()) {
           func->body =
             builder.makeConstantExpression(Literal::makeZeros(sig.results));
+        } else {
+          // We have nothing better than the trap here.
+          func->body = builder.makeUnreachable();
         }
       }
 
diff --git a/test/lit/passes/legalize-and-prune-js-interface.wast b/test/lit/passes/legalize-and-prune-js-interface.wast
index 0840ddbdd57..01b89d42912 100644
--- a/test/lit/passes/legalize-and-prune-js-interface.wast
+++ b/test/lit/passes/legalize-and-prune-js-interface.wast
@@ -14,6 +14,13 @@
 
   (import "env" "imported-v128-param-noresult" (func $imported-v128-param-noresult (param v128)))
 
+  ;; The results here include a nullable value, which we will emit a null for.
+  (import "env" "imported-v128-defaultable" (func $imported-v128-defaultable (result v128 anyref)))
+
+  ;; The results here include a non-nullable value, which will force us to emit
+  ;; an unreachable.
+  (import "env" "imported-v128-nondefaultable" (func $imported-v128-nondefaultable (result v128 (ref any))))
+
   ;; CHECK:      (type $0 (func (result v128)))
 
   ;; CHECK:      (type $1 (func (result i32 f64)))
@@ -22,17 +29,21 @@
 
   ;; CHECK:      (type $3 (func (param v128)))
 
-  ;; CHECK:      (type $4 (func))
+  ;; CHECK:      (type $4 (func (result v128 anyref)))
+
+  ;; CHECK:      (type $5 (func (result v128 (ref any))))
 
-  ;; CHECK:      (type $5 (func (result i32)))
+  ;; CHECK:      (type $6 (func))
 
-  ;; CHECK:      (type $6 (func (param i32 f64) (result i64)))
+  ;; CHECK:      (type $7 (func (result i32)))
 
-  ;; CHECK:      (type $7 (func (param i32 f64) (result i32)))
+  ;; CHECK:      (type $8 (func (param i32 f64) (result i64)))
 
-  ;; CHECK:      (import "env" "getTempRet0" (func $getTempRet0 (type $5) (result i32)))
+  ;; CHECK:      (type $9 (func (param i32 f64) (result i32)))
 
-  ;; CHECK:      (import "env" "imported-64" (func $legalimport$imported-64 (type $7) (param i32 f64) (result i32)))
+  ;; CHECK:      (import "env" "getTempRet0" (func $getTempRet0 (type $7) (result i32)))
+
+  ;; CHECK:      (import "env" "imported-64" (func $legalimport$imported-64 (type $9) (param i32 f64) (result i32)))
 
   ;; CHECK:      (func $imported-v128 (type $0) (result v128)
   ;; CHECK-NEXT:  (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
@@ -53,7 +64,18 @@
   ;; CHECK-NEXT:  (nop)
   ;; CHECK-NEXT: )
 
-  ;; CHECK:      (func $call-64 (type $4)
+  ;; CHECK:      (func $imported-v128-defaultable (type $4) (result v128 anyref)
+  ;; CHECK-NEXT:  (tuple.make 2
+  ;; CHECK-NEXT:   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+  ;; CHECK-NEXT:   (ref.null none)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $imported-v128-nondefaultable (type $5) (result v128 (ref any))
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $call-64 (type $6)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (call $legalfunc$imported-64
   ;; CHECK-NEXT:    (i32.const 0)
@@ -103,7 +125,7 @@
   )
 )
 
-;; CHECK:      (func $legalfunc$imported-64 (type $6) (param $0 i32) (param $1 f64) (result i64)
+;; CHECK:      (func $legalfunc$imported-64 (type $8) (param $0 i32) (param $1 f64) (result i64)
 ;; CHECK-NEXT:  (i64.or
 ;; CHECK-NEXT:   (i64.extend_i32_u
 ;; CHECK-NEXT:    (call $legalimport$imported-64

From 9d738a48176306324cbf3e79c75e6c6adb7c5c90 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 12:47:51 -0700
Subject: [PATCH 18/42] typo

---
 src/passes/LegalizeJSInterface.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/passes/LegalizeJSInterface.cpp b/src/passes/LegalizeJSInterface.cpp
index 2881a2e1623..4509f280b23 100644
--- a/src/passes/LegalizeJSInterface.cpp
+++ b/src/passes/LegalizeJSInterface.cpp
@@ -395,7 +395,7 @@ struct LegalizeAndPruneJSInterface : public LegalizeJSInterface {
           func->body =
             builder.makeConstantExpression(Literal::makeZeros(sig.results));
         } else {
-          // We have nothing better than the trap here.
+          // We have nothing better than to trap here.
           func->body = builder.makeUnreachable();
         }
       }

From 53a5b4d61476918262bc2f3231bdc361693326ca Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 12:47:51 -0700
Subject: [PATCH 19/42] typo

---
 src/passes/LegalizeJSInterface.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/passes/LegalizeJSInterface.cpp b/src/passes/LegalizeJSInterface.cpp
index 2881a2e1623..4509f280b23 100644
--- a/src/passes/LegalizeJSInterface.cpp
+++ b/src/passes/LegalizeJSInterface.cpp
@@ -395,7 +395,7 @@ struct LegalizeAndPruneJSInterface : public LegalizeJSInterface {
           func->body =
             builder.makeConstantExpression(Literal::makeZeros(sig.results));
         } else {
-          // We have nothing better than the trap here.
+          // We have nothing better than to trap here.
           func->body = builder.makeUnreachable();
         }
       }

From 44aeb93cb8f2ad9423aab1d1d69faeed04807b02 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 13:06:21 -0700
Subject: [PATCH 20/42] format

---
 src/tools/fuzzing.h           |  2 +-
 src/tools/fuzzing/fuzzing.cpp |  3 ++-
 src/tools/wasm-opt.cpp        | 15 +++++++--------
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/tools/fuzzing.h b/src/tools/fuzzing.h
index 76dfc7d67a6..161ccd6d139 100644
--- a/src/tools/fuzzing.h
+++ b/src/tools/fuzzing.h
@@ -162,7 +162,7 @@ class TranslateToFuzzReader {
 
   // An optional module to import from.
   std::optional<std::string> importedModule;
-  
+
   // Whether we allow the fuzzer to add unreachable code when generating changes
   // to existing code. This is randomized during startup, but could be an option
   // like the above options eventually if we find that useful.
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index 5c8c741ecc6..e9f8bd5c5e8 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -1181,7 +1181,8 @@ void TranslateToFuzzReader::useImportedModule() {
     }
 
     auto* func = imported.getFunction(*exp->getInternalName());
-    auto name = Names::getValidFunctionName(wasm, "primary_" + exp->name.toString());
+    auto name =
+      Names::getValidFunctionName(wasm, "primary_" + exp->name.toString());
     // We can import it as its own type, or any (declared) supertype.
     auto type = getSuperType(func->type);
     auto import = builder.makeFunction(name, type, {});
diff --git a/src/tools/wasm-opt.cpp b/src/tools/wasm-opt.cpp
index 7735c5b2dcf..26cb0140da8 100644
--- a/src/tools/wasm-opt.cpp
+++ b/src/tools/wasm-opt.cpp
@@ -202,14 +202,13 @@ For more on how to optimize effectively, see
          [&](Options* o, const std::string& arguments) {
            fuzzPreserveImportsAndExports = true;
          })
-    .add("--fuzz-import",
-         "",
-         "a module to use as an import in -ttf mode",
-         WasmOptOption,
-         Options::Arguments::One,
-         [&](Options* o, const std::string& arguments) {
-           fuzzImport = arguments;
-         })
+    .add(
+      "--fuzz-import",
+      "",
+      "a module to use as an import in -ttf mode",
+      WasmOptOption,
+      Options::Arguments::One,
+      [&](Options* o, const std::string& arguments) { fuzzImport = arguments; })
     .add("--emit-spec-wrapper",
          "-esw",
          "Emit a wasm spec interpreter wrapper file that can run the wasm with "

From 31d8934f39591c8bbfab72688bc0b3f4df1df892 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Fri, 3 Oct 2025 13:06:42 -0700
Subject: [PATCH 21/42] fix

---
 scripts/fuzz_opt.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index 81c834ddfac..67ee66b1f53 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -754,6 +754,7 @@ def __init__(self):
     # care about their relationship.
     def handle_pair(self, input, before_wasm, after_wasm, opts):
         self.handle(before_wasm)
+        # Add some visual space between the independent parts.
         print('\n')
         self.handle(after_wasm)
 

From 4b63f2be1fe7d978baa481981ec4080e69a2cf4c Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 09:20:07 -0700
Subject: [PATCH 22/42] CF.too

---
 scripts/clusterfuzz/run.py     | 43 +++++++++++++++++++++++++---------
 test/unit/test_cluster_fuzz.py | 17 +++++++++++++-
 2 files changed, 48 insertions(+), 12 deletions(-)

diff --git a/scripts/clusterfuzz/run.py b/scripts/clusterfuzz/run.py
index 70b6bf89776..a07b856d10d 100755
--- a/scripts/clusterfuzz/run.py
+++ b/scripts/clusterfuzz/run.py
@@ -123,6 +123,9 @@ def get_random_initial_content():
 # allows us to debug any such failures that we run into.
 retry = True
 
+# Temporary files to clean up
+temp_files = []
+
 
 # Generate a random wasm file, and return a string that creates a typed array of
 # those bytes, suitable for use in a JS file, in the form
@@ -130,7 +133,9 @@ def get_random_initial_content():
 #   new Uint8Array([..wasm_contents..])
 #
 # Receives the testcase index and the output dir.
-def get_wasm_contents(i, output_dir):
+#
+# Also returns the name of the wasm file.
+def get_wasm_contents(i, output_dir, extra_args=[]):
     input_data_file_path = os.path.join(output_dir, f'{i}.input')
     wasm_file_path = os.path.join(output_dir, f'{i}.wasm')
 
@@ -144,7 +149,7 @@ def get_wasm_contents(i, output_dir):
 
         # Generate a command to use wasm-opt with the proper args to generate
         # wasm content from the input data.
-        cmd = [FUZZER_BINARY_PATH] + FUZZER_ARGS
+        cmd = [FUZZER_BINARY_PATH] + FUZZER_ARGS + extra_args
         cmd += ['-o', wasm_file_path, input_data_file_path]
 
         # Sometimes use a file from the initial content testcases.
@@ -177,16 +182,19 @@ def get_wasm_contents(i, output_dir):
     with open(wasm_file_path, 'rb') as file:
         wasm_contents = file.read()
 
-    # Clean up temp files.
-    os.remove(wasm_file_path)
-    os.remove(input_data_file_path)
+    # Note temp files.
+    global temp_files
+    temp_files += [
+        wasm_file_path,
+        input_data_file_path
+    ]
 
     # Convert to a string, and wrap into a typed array.
     wasm_contents = ','.join([str(c) for c in wasm_contents])
     js = f'new Uint8Array([{wasm_contents}])'
     if initial_content:
         js = f'{js} /* using initial content {os.path.basename(initial_content)} */'
-    return js
+    return js, wasm_file_path
 
 
 # Returns the contents of a .js fuzz file, given the index of the testcase and
@@ -198,7 +206,7 @@ def get_js_file_contents(i, output_dir):
 
     # Prepend the wasm contents, so they are used (rather than the normal
     # mechanism where the wasm file's name is provided in argv).
-    wasm_contents = get_wasm_contents(i, output_dir)
+    wasm_contents, wasm_file = get_wasm_contents(i, output_dir)
     pre = f'var binary = {wasm_contents};\n'
     bytes = wasm_contents.count(',')
 
@@ -206,9 +214,14 @@ def get_js_file_contents(i, output_dir):
     has_second = False
     if system_random.random() < 0.333:
         has_second = True
-        wasm_contents = get_wasm_contents(i, output_dir)
-        pre += f'var secondBinary = {wasm_contents};\n'
-        bytes += wasm_contents.count(',')
+        # Sometimes import the first file.
+        args = []
+        if system_random.random() < 0.5:
+            args = [f'--fuzz-import={wasm_file}']
+        second_wasm_contents, second_wasm_file = \
+            get_wasm_contents(i, output_dir, args)
+        pre += f'var secondBinary = {second_wasm_contents};\n'
+        bytes += second_wasm_contents.count(',')
 
     js = pre + '\n' + js
 
@@ -243,7 +256,9 @@ def get_js_file_contents(i, output_dir):
     ]
     if has_second:
         extra_js_operations += [
-            'build(secondBinary)',
+            # Build the second binary, marking it as second so it imports the
+            # first.
+            'build(secondBinary, true)',
         ]
 
     for i in range(num):
@@ -307,6 +322,12 @@ def main(argv):
 
     print(f'Created {num} testcases.')
 
+    for temp in temp_files:
+        if os.path.exists(temp):
+            os.remove(temp)
+
+    print(f'Cleaned up.')
+
 
 if __name__ == '__main__':
     main(sys.argv)
diff --git a/test/unit/test_cluster_fuzz.py b/test/unit/test_cluster_fuzz.py
index e69b99eeb82..bec015380d8 100644
--- a/test/unit/test_cluster_fuzz.py
+++ b/test/unit/test_cluster_fuzz.py
@@ -165,8 +165,10 @@ def test_file_contents(self):
         seen_sizes = []
         seen_exports = []
 
-        # Second wasm files are also emitted sometimes.
+        # Second wasm files are also emitted sometimes, and sometimes they
+        # import the primary module.
         seen_second_sizes = []
+        seen_primary_imports = 0
 
         # The number of struct.news appears in the metrics report like this:
         #
@@ -230,6 +232,12 @@ def test_file_contents(self):
                 # sizes, is enough).
                 seen_second_sizes.append(os.path.getsize(second_binary_file))
 
+                # The primary module should be imported sometimes.
+                wat = subprocess.check_output(
+                    shared.WASM_DIS + [second_binary_file], text=True)
+                if '(import "primary" ' in wat:
+                    seen_primary_imports += 1
+
         print()
 
         print('struct.news can vary a lot, but should be ~10')
@@ -278,6 +286,13 @@ def test_file_contents(self):
 
         print()
 
+        # Primary imports appear in half of second files.
+        print('number of primary imports should be around 16 +- 4')
+        print(f'number of primary_imports: {seen_primary_imports}')
+        assert seen_primary_imports >= 2, 'must see some primary import'
+
+        print()
+
         # To check for interesting JS file contents, we'll note how many times
         # we build and run the wasm, and other things like JSPI.
         seen_builds = []

From 4cc8e45fa807e9d0a2da59f7e513dd58870943be Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 09:39:39 -0700
Subject: [PATCH 23/42] fix

---
 scripts/clusterfuzz/run.py     | 4 ++--
 test/unit/test_cluster_fuzz.py | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/scripts/clusterfuzz/run.py b/scripts/clusterfuzz/run.py
index a07b856d10d..493346b6c9f 100755
--- a/scripts/clusterfuzz/run.py
+++ b/scripts/clusterfuzz/run.py
@@ -214,9 +214,9 @@ def get_js_file_contents(i, output_dir):
     has_second = False
     if system_random.random() < 0.333:
         has_second = True
-        # Sometimes import the first file.
+        # Most of the time, import the first file.
         args = []
-        if system_random.random() < 0.5:
+        if system_random.random() < 0.8:
             args = [f'--fuzz-import={wasm_file}']
         second_wasm_contents, second_wasm_file = \
             get_wasm_contents(i, output_dir, args)
diff --git a/test/unit/test_cluster_fuzz.py b/test/unit/test_cluster_fuzz.py
index bec015380d8..f35aa60dd2d 100644
--- a/test/unit/test_cluster_fuzz.py
+++ b/test/unit/test_cluster_fuzz.py
@@ -287,9 +287,9 @@ def test_file_contents(self):
         print()
 
         # Primary imports appear in half of second files.
-        print('number of primary imports should be around 16 +- 4')
+        print('number of primary imports should be around 22 +- 4')
         print(f'number of primary_imports: {seen_primary_imports}')
-        assert seen_primary_imports >= 2, 'must see some primary import'
+        assert seen_primary_imports >= 2, 'must see some primary imports'
 
         print()
 
@@ -322,7 +322,7 @@ def test_file_contents(self):
                 js = f.read()
             seen_builds.append(js.count('build(binary);'))
             seen_calls.append(re.findall(call_exports_regex, js))
-            seen_second_builds.append(js.count('build(secondBinary);'))
+            seen_second_builds.append(js.count('build(secondBinary, true);'))
 
             # If JSPI is enabled, the async and await keywords should be
             # enabled (uncommented).

From b49eaf65c320166ba23fbb77af29368c4c5bbb92 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 09:51:20 -0700
Subject: [PATCH 24/42] fix

---
 scripts/clusterfuzz/run.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/scripts/clusterfuzz/run.py b/scripts/clusterfuzz/run.py
index 493346b6c9f..a929cc25560 100755
--- a/scripts/clusterfuzz/run.py
+++ b/scripts/clusterfuzz/run.py
@@ -135,9 +135,9 @@ def get_random_initial_content():
 # Receives the testcase index and the output dir.
 #
 # Also returns the name of the wasm file.
-def get_wasm_contents(i, output_dir, extra_args=[]):
-    input_data_file_path = os.path.join(output_dir, f'{i}.input')
-    wasm_file_path = os.path.join(output_dir, f'{i}.wasm')
+def get_wasm_contents(name, output_dir, extra_args=[]):
+    input_data_file_path = os.path.join(output_dir, f'{name}.input')
+    wasm_file_path = os.path.join(output_dir, f'{name}.wasm')
 
     # wasm-opt may fail to run in rare cases (when the fuzzer emits code it
     # detects as invalid). Just try again in such a case.
@@ -219,7 +219,7 @@ def get_js_file_contents(i, output_dir):
         if system_random.random() < 0.8:
             args = [f'--fuzz-import={wasm_file}']
         second_wasm_contents, second_wasm_file = \
-            get_wasm_contents(i, output_dir, args)
+            get_wasm_contents(f'{i}_second', output_dir, args)
         pre += f'var secondBinary = {second_wasm_contents};\n'
         bytes += second_wasm_contents.count(',')
 
@@ -323,8 +323,7 @@ def main(argv):
     print(f'Created {num} testcases.')
 
     for temp in temp_files:
-        if os.path.exists(temp):
-            os.remove(temp)
+        os.remove(temp)
 
     print(f'Cleaned up.')
 

From 05a296aacafc1099a58e9a1a1d7cf4e03fbc5f7f Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 09:55:24 -0700
Subject: [PATCH 25/42] back

---
 scripts/fuzz_opt.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index 67ee66b1f53..afbb33ee94e 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -2135,7 +2135,19 @@ def handle(self, wasm):
 
 # The global list of all test case handlers
 testcase_handlers = [
+    FuzzExec(),
+    CompareVMs(),
+    CheckDeterminism(),
+    Wasm2JS(),
+    TrapsNeverHappen(),
+    CtorEval(),
+    Merge(),
+    Split(),
+    RoundtripText(),
+    ClusterFuzz(),
     Two(),
+    PreserveImportsExports(),
+    BranchHintPreservation(),
 ]
 
 

From f2d6c1aa93d618038e75d9b945cfdc6f757f3d02 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 12:24:37 -0700
Subject: [PATCH 26/42] freqs

---
 scripts/fuzz_opt.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index afbb33ee94e..3e3b1024b9f 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1780,7 +1780,7 @@ def ensure(self):
 # anything. This is similar to Split(), but rather than split a wasm file into
 # two and link them at runtime, this starts with two separate wasm files.
 class Two(TestCaseHandler):
-    frequency = 1 # 0.2
+    frequency = 0.2
 
     def handle(self, wasm):
         # Generate a second wasm file, unless we were given one (useful during
@@ -1795,7 +1795,7 @@ def handle(self, wasm):
             make_random_input(random_size(), second_input)
             args = [second_input, '-ttf', '-o', second_wasm]
             # Most of the time, use the first wasm as an import to the second.
-            if random.random() < 0.5:
+            if random.random() < 0.8:
                 args += ['--fuzz-import=' + wasm]
             run([in_bin('wasm-opt')] + args + GEN_ARGS + FEATURE_OPTS)
 

From 57332602a6b183e59cd525c659a991139173c855 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 12:30:29 -0700
Subject: [PATCH 27/42] clean

---
 src/tools/fuzzing/fuzzing.cpp |  2 +-
 test/lit/fuzz-import.wast     | 19 ++++++++++---------
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index e9f8bd5c5e8..4d7a954d11c 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -1592,7 +1592,7 @@ Function* TranslateToFuzzReader::addFunction() {
     wasm.addExport(
       Builder::makeExport(func->name, func->name, ExternalKind::Function));
   }
-  // add some to an elem segment
+  // add some to an elem segment TODO we could do this for imported funcs too
   while (oneIn(3) && !random.finished()) {
     auto type = Type(func->type, NonNullable);
     std::vector<ElementSegment*> compatibleSegments;
diff --git a/test/lit/fuzz-import.wast b/test/lit/fuzz-import.wast
index 7974c921311..58fa22e19b0 100644
--- a/test/lit/fuzz-import.wast
+++ b/test/lit/fuzz-import.wast
@@ -1,21 +1,22 @@
 ;; Test the flag to import from a given module in fuzzer generation.
 
-;; Generate fuzz output using this wat as initial contents, and with the flag to
-;; preserve imports and exports. There should be no new imports or exports, and
-;; old ones must stay the same.
-
+;; Generate fuzz output using this wat as initial contents, and importing the
+;; side file.
 ;; RUN: wasm-opt %s.ttf --initial-fuzz=%s -all -ttf --fuzz-import=%s.import.wast \
 ;; RUN:          -S -o - | filecheck %s
 
 (module
   ;; This existing import will be made a non-import, but the ones from the
   ;; imported module will be ok.
-  (import "a" "b" (func $import))
+  (import "existing" "foo" (func $import))
 )
 
-;; We must see an import from the primary module
+;; CHECK-NOT:      (import "existing"
+
+;; We must see an import from the primary module.
 ;; XXX This does depend on random choices in the fuzzer. We do have many chances
-;;     to emit one such import, but if this turns out to be too unlikely, we
-;;     can remove this test and depend on the fuzzer.
-;; CHECK:      (import "primary" 
+;;     to emit one such import (see the large file on the side), but if this
+;;     turns out to be too unlikely, we can remove this test in favor of a unit
+;;     test or the fuzzer.
+;; CHECK:      (import "primary"
 

From f4f30e913721c8e7d2e5d358382c51a2f1033a3d Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 12:31:33 -0700
Subject: [PATCH 28/42] clean

---
 test/unit/test_cluster_fuzz.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/unit/test_cluster_fuzz.py b/test/unit/test_cluster_fuzz.py
index f35aa60dd2d..ce5b5421669 100644
--- a/test/unit/test_cluster_fuzz.py
+++ b/test/unit/test_cluster_fuzz.py
@@ -286,7 +286,7 @@ def test_file_contents(self):
 
         print()
 
-        # Primary imports appear in half of second files.
+        # Primary imports appear in most second files.
         print('number of primary imports should be around 22 +- 4')
         print(f'number of primary_imports: {seen_primary_imports}')
         assert seen_primary_imports >= 2, 'must see some primary imports'

From cb9a6084878bcec69db8d637949886c3cbd8d02c Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 12:36:58 -0700
Subject: [PATCH 29/42] fix

---
 test/lit/fuzz-import.wast                                       | 2 +-
 .../{fuzz-import.wast.import.wast => fuzz-import.wast.import}   | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename test/lit/{fuzz-import.wast.import.wast => fuzz-import.wast.import} (100%)

diff --git a/test/lit/fuzz-import.wast b/test/lit/fuzz-import.wast
index 58fa22e19b0..2c2c00ed949 100644
--- a/test/lit/fuzz-import.wast
+++ b/test/lit/fuzz-import.wast
@@ -2,7 +2,7 @@
 
 ;; Generate fuzz output using this wat as initial contents, and importing the
 ;; side file.
-;; RUN: wasm-opt %s.ttf --initial-fuzz=%s -all -ttf --fuzz-import=%s.import.wast \
+;; RUN: wasm-opt %s.ttf --initial-fuzz=%s -all -ttf --fuzz-import=%s.import \
 ;; RUN:          -S -o - | filecheck %s
 
 (module
diff --git a/test/lit/fuzz-import.wast.import.wast b/test/lit/fuzz-import.wast.import
similarity index 100%
rename from test/lit/fuzz-import.wast.import.wast
rename to test/lit/fuzz-import.wast.import

From dc899d3e26ce7e391c7a21b152df18e10358b6a9 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 12:44:13 -0700
Subject: [PATCH 30/42] linkt

---
 scripts/clusterfuzz/run.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/clusterfuzz/run.py b/scripts/clusterfuzz/run.py
index a929cc25560..c47c2e77048 100755
--- a/scripts/clusterfuzz/run.py
+++ b/scripts/clusterfuzz/run.py
@@ -325,7 +325,7 @@ def main(argv):
     for temp in temp_files:
         os.remove(temp)
 
-    print(f'Cleaned up.')
+    print('Cleaned up.')
 
 
 if __name__ == '__main__':

From 180f10296b721d68664688bb366e65d3971d2abf Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 12:56:12 -0700
Subject: [PATCH 31/42] go

---
 scripts/fuzz_opt.py | 89 ++++++++++++++++++++++-----------------------
 1 file changed, 44 insertions(+), 45 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index 3e3b1024b9f..eb8681efe27 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1780,7 +1780,7 @@ def ensure(self):
 # anything. This is similar to Split(), but rather than split a wasm file into
 # two and link them at runtime, this starts with two separate wasm files.
 class Two(TestCaseHandler):
-    frequency = 0.2
+    frequency = 1 # 0.5
 
     def handle(self, wasm):
         # Generate a second wasm file, unless we were given one (useful during
@@ -1799,21 +1799,58 @@ def handle(self, wasm):
                 args += ['--fuzz-import=' + wasm]
             run([in_bin('wasm-opt')] + args + GEN_ARGS + FEATURE_OPTS)
 
-        # The binaryen interpreter only supports a single file, so we run them
-        # from JS using fuzz_shell.js's support for two files.
+        # Run the wasm.
         #
         # Note that we *cannot* run each wasm file separately and compare those
         # to the combined output, as fuzz_shell.js intentionally allows calls
         # *between* the wasm files, through JS APIs like call-export*. So all we
         # do here is see the combined, linked behavior, and then later below we
         # see that that behavior remains even after optimizations.
-        output = run_d8_wasm(wasm, args=[second_wasm])
+        output = run_bynterp(wasm, args=[f'--fuzz-exec-second={second_wasm}z'])
 
         if output == IGNORE:
             # There is no point to continue since we can't compare this output
             # to anything.
             return
 
+        # Make sure that we actually executed all exports from both
+        # wasm files.
+        exports = get_exports(wasm, ['func']) + get_exports(second_wasm, ['func'])
+        calls_in_output = output.count(FUZZ_EXEC_CALL_PREFIX)
+        if calls_in_output == 0:
+            print(f'warning: no calls in output. output:\n{output}')
+        assert calls_in_output == len(exports)
+
+        output = fix_output(output)
+
+        # Optimize at least one of the two.
+        wasms = [wasm, second_wasm]
+        for i in range(random.randint(1, 2)):
+            wasm_index = random.randint(0, 1)
+            name = wasms[wasm_index]
+            new_name = name + f'.opt{i}.wasm'
+            opts = get_random_opts()
+            run([in_bin('wasm-opt'), name, '-o', new_name] + opts + FEATURE_OPTS)
+            wasms[wasm_index] = new_name
+
+        # Run again, and compare the output
+        optimized_output = run_bynterp(wasms[0], args=[f'--fuzz-exec-second={wasms[1]}'])
+        optimized_output = fix_output(optimized_output)
+
+        compare(output, optimized_output, 'Two')
+
+        # If we can, also test in V8. We also cannot compare if there are NaNs
+        # (as optimizations can lead to different outputs), and we must
+        # disallow some features.
+        # TODO: relax some of these
+        if NANS or not all_disallowed(['shared-everything', 'strings', 'stack-switching']):
+            return
+
+        output = run_d8_wasm(wasm, args=[second_wasm])
+
+        if output == IGNORE:
+            return
+
         if output.startswith(INSTANTIATE_ERROR):
             # We may fail to instantiate the modules for valid reasons, such as
             # an active segment being out of bounds. There is no point to
@@ -1834,43 +1871,17 @@ def handle(self, wasm):
             note_ignored_vm_run('Two instantiate error')
             return
 
-        # Make sure that fuzz_shell.js actually executed all exports from both
-        # wasm files.
-        exports = get_exports(wasm, ['func']) + get_exports(second_wasm, ['func'])
-        calls_in_output = output.count(FUZZ_EXEC_CALL_PREFIX)
-        if calls_in_output == 0:
-            print(f'warning: no calls in output. output:\n{output}')
-        assert calls_in_output == len(exports)
-
         output = fix_output(output)
 
-        # Optimize at least one of the two.
-        wasms = [wasm, second_wasm]
-        for i in range(random.randint(1, 2)):
-            wasm_index = random.randint(0, 1)
-            name = wasms[wasm_index]
-            new_name = name + f'.opt{i}.wasm'
-            opts = get_random_opts()
-            run([in_bin('wasm-opt'), name, '-o', new_name] + opts + FEATURE_OPTS)
-            wasms[wasm_index] = new_name
-
-        # Run again, and compare the output
         optimized_output = run_d8_wasm(wasms[0], args=[wasms[1]])
         optimized_output = fix_output(optimized_output)
 
-        compare(output, optimized_output, 'Two')
+        compare(output, optimized_output, 'Two-V8')
 
     def can_run_on_wasm(self, wasm):
         # We cannot optimize wasm files we are going to link in closed world
-        # mode. We also cannot run shared-everything code in d8 yet. We also
-        # cannot compare if there are NaNs (as optimizations can lead to
-        # different outputs).
-        # TODO: relax some of these
-        if CLOSED_WORLD:
-            return False
-        if NANS:
-            return False
-        return all_disallowed(['shared-everything', 'strings', 'stack-switching'])
+        # mode.
+        return not CLOSED_WORLD
 
 
 # Test --fuzz-preserve-imports-exports, which never modifies imports or exports.
@@ -2135,19 +2146,7 @@ def handle(self, wasm):
 
 # The global list of all test case handlers
 testcase_handlers = [
-    FuzzExec(),
-    CompareVMs(),
-    CheckDeterminism(),
-    Wasm2JS(),
-    TrapsNeverHappen(),
-    CtorEval(),
-    Merge(),
-    Split(),
-    RoundtripText(),
-    ClusterFuzz(),
     Two(),
-    PreserveImportsExports(),
-    BranchHintPreservation(),
 ]
 
 

From 233cfcd76602650d85624a7a0e10034ac61160f7 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 13:26:39 -0700
Subject: [PATCH 32/42] work

---
 scripts/fuzz_opt.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index eb8681efe27..e458bd8a7c1 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1791,8 +1791,13 @@ def handle(self, wasm):
             # TODO: should we de-nan this etc. as with the primary?
             shutil.copyfile(given, second_wasm)
         else:
+            # generate a second wasm file to merge. pick a smaller size when
+            # the main wasm file is smaller, so reduction shrinks this too.
+            wasm_size = os.stat(wasm).st_size
+            second_size = min(wasm_size, random_size())
+
             second_input = abspath('second_input.dat')
-            make_random_input(random_size(), second_input)
+            make_random_input(second_size, second_input)
             args = [second_input, '-ttf', '-o', second_wasm]
             # Most of the time, use the first wasm as an import to the second.
             if random.random() < 0.8:
@@ -1806,7 +1811,7 @@ def handle(self, wasm):
         # *between* the wasm files, through JS APIs like call-export*. So all we
         # do here is see the combined, linked behavior, and then later below we
         # see that that behavior remains even after optimizations.
-        output = run_bynterp(wasm, args=[f'--fuzz-exec-second={second_wasm}z'])
+        output = run_bynterp(wasm, args=['--fuzz-exec-before', f'--fuzz-exec-second={second_wasm}'])
 
         if output == IGNORE:
             # There is no point to continue since we can't compare this output
@@ -1819,7 +1824,7 @@ def handle(self, wasm):
         calls_in_output = output.count(FUZZ_EXEC_CALL_PREFIX)
         if calls_in_output == 0:
             print(f'warning: no calls in output. output:\n{output}')
-        assert calls_in_output == len(exports)
+        assert calls_in_output == len(exports), exports
 
         output = fix_output(output)
 
@@ -1834,7 +1839,7 @@ def handle(self, wasm):
             wasms[wasm_index] = new_name
 
         # Run again, and compare the output
-        optimized_output = run_bynterp(wasms[0], args=[f'--fuzz-exec-second={wasms[1]}'])
+        optimized_output = run_bynterp(wasms[0], args=['--fuzz-exec-before', f'--fuzz-exec-second={wasms[1]}'])
         optimized_output = fix_output(optimized_output)
 
         compare(output, optimized_output, 'Two')

From 063e90974b25c44066d79a56622726051b30576f Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 16:01:14 -0700
Subject: [PATCH 33/42] fix

---
 scripts/fuzz_opt.py           | 15 +++++++++------
 src/tools/execution-results.h |  8 +++++++-
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index e458bd8a7c1..c5add657c96 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1813,6 +1813,13 @@ def handle(self, wasm):
         # see that that behavior remains even after optimizations.
         output = run_bynterp(wasm, args=['--fuzz-exec-before', f'--fuzz-exec-second={second_wasm}'])
 
+        if INSTANTIATE_ERROR in output:
+            # We may fail to instantiate the modules for valid reasons, such as
+            # an active segment being out of bounds. There is no point to
+            # continue in such cases, as no exports are called.
+            note_ignored_vm_run('Two instantiate error')
+            return
+
         if output == IGNORE:
             # There is no point to continue since we can't compare this output
             # to anything.
@@ -1857,11 +1864,7 @@ def handle(self, wasm):
             return
 
         if output.startswith(INSTANTIATE_ERROR):
-            # We may fail to instantiate the modules for valid reasons, such as
-            # an active segment being out of bounds. There is no point to
-            # continue in such cases, as no exports are called.
-
-            # But, check 'primary' is not in the V8 error. That might indicate a
+            # Check 'primary' is not in the V8 error. That might indicate a
             # problem in the imports of --fuzz-import. To do this, run the d8
             # command directly, without the usual filtering of run_d8_wasm.
             cmd = [shared.V8] + shared.V8_OPTS + get_v8_extra_flags() + [
@@ -1873,7 +1876,7 @@ def handle(self, wasm):
             out = run(cmd)
             assert '"primary"' not in out, out
 
-            note_ignored_vm_run('Two instantiate error')
+            note_ignored_vm_run('Two-V8 instantiate error')
             return
 
         output = fix_output(output)
diff --git a/src/tools/execution-results.h b/src/tools/execution-results.h
index 0afdff0cde8..8257df07afe 100644
--- a/src/tools/execution-results.h
+++ b/src/tools/execution-results.h
@@ -297,6 +297,7 @@ struct ExecutionResults {
 
       if (second) {
         // Link and run the second module.
+        std::cout << "[fuzz-exec] running second module\n";
         std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances;
         linkedInstances["primary"] = instance;
         LoggingExternalInterface secondInterface(
@@ -321,7 +322,12 @@ struct ExecutionResults {
     // This is not an optimization: we want to execute anything, even relaxed
     // SIMD instructions.
     instance.setRelaxedBehavior(ModuleRunner::RelaxedBehavior::Execute);
-    instance.instantiate();
+    try {
+      instance.instantiate();
+    } catch (const TrapException&) {
+      std::cout << "exception thrown: failed to instantiate module\n";
+      throw;
+    }
     interface.setModuleRunner(&instance);
     // execute all exported methods (that are therefore preserved through
     // opts)

From ffe63c76febb0e7c6dddc031509783141e3a4f75 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 16:15:47 -0700
Subject: [PATCH 34/42] now

---
 scripts/fuzz_opt.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index c5add657c96..7e02a19fff7 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1674,7 +1674,7 @@ def handle(self, wasm):
 # like ClusterFuzz does, and that generates its own random data. If a bug is
 # caught here, it must be reduced manually.
 class ClusterFuzz(TestCaseHandler):
-    frequency = 0.1
+    frequency = 1
 
     # Use handle_pair over handle because we don't use these wasm files anyhow,
     # we generate our own using run.py. If we used handle, we'd be called twice
@@ -2154,7 +2154,19 @@ def handle(self, wasm):
 
 # The global list of all test case handlers
 testcase_handlers = [
+    FuzzExec(),
+    CompareVMs(),
+    CheckDeterminism(),
+    Wasm2JS(),
+    TrapsNeverHappen(),
+    CtorEval(),
+    Merge(),
+    Split(),
+    RoundtripText(),
+    ClusterFuzz(),
     Two(),
+    PreserveImportsExports(),
+    BranchHintPreservation(),
 ]
 
 

From 80faed37ea59dd534e073192a94eb7c327c6c13d Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 16:47:09 -0700
Subject: [PATCH 35/42] fix

---
 src/tools/execution-results.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/tools/execution-results.h b/src/tools/execution-results.h
index 8257df07afe..89df792e9d2 100644
--- a/src/tools/execution-results.h
+++ b/src/tools/execution-results.h
@@ -324,9 +324,12 @@ struct ExecutionResults {
     instance.setRelaxedBehavior(ModuleRunner::RelaxedBehavior::Execute);
     try {
       instance.instantiate();
-    } catch (const TrapException&) {
-      std::cout << "exception thrown: failed to instantiate module\n";
-      throw;
+    } catch (const TrapException& t) {
+      // Print the exception,  also prefixed to note it is an instantiation
+      // failure specifically.
+      std::cout << "exception thrown: failed to instantiate module" << t
+                << "\n";
+      return;
     }
     interface.setModuleRunner(&instance);
     // execute all exported methods (that are therefore preserved through

From 3b89ddce645045232815c1d66ec9250da75337d9 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 16:49:44 -0700
Subject: [PATCH 36/42] fix

---
 scripts/fuzz_opt.py           | 7 +++++--
 src/tools/execution-results.h | 5 +----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index 7e02a19fff7..e396284925d 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1660,9 +1660,12 @@ def handle(self, wasm):
         run([in_bin('wasm-opt'), abspath('a.wast')] + FEATURE_OPTS)
 
 
-# The error shown when a module fails to instantiate.
+# The error shown in V8 when a module fails to instantiate.
 INSTANTIATE_ERROR = 'exception thrown: failed to instantiate module'
 
+# The logging Binaryen emits with fuzz-exec hits an instantiation error.
+BYN_INSTANTIATE_ERROR = '[fuzz-exec] stopping after instantiation error'
+
 
 # Fuzz in a near-identical manner to how we fuzz on ClusterFuzz. This is mainly
 # to see that fuzzing that way works properly (it likely won't catch anything
@@ -1813,7 +1816,7 @@ def handle(self, wasm):
         # see that that behavior remains even after optimizations.
         output = run_bynterp(wasm, args=['--fuzz-exec-before', f'--fuzz-exec-second={second_wasm}'])
 
-        if INSTANTIATE_ERROR in output:
+        if BYN_INSTANTIATE_ERROR in output:
             # We may fail to instantiate the modules for valid reasons, such as
             # an active segment being out of bounds. There is no point to
             # continue in such cases, as no exports are called.
diff --git a/src/tools/execution-results.h b/src/tools/execution-results.h
index 89df792e9d2..243ff262594 100644
--- a/src/tools/execution-results.h
+++ b/src/tools/execution-results.h
@@ -325,10 +325,7 @@ struct ExecutionResults {
     try {
       instance.instantiate();
     } catch (const TrapException& t) {
-      // Print the exception,  also prefixed to note it is an instantiation
-      // failure specifically.
-      std::cout << "exception thrown: failed to instantiate module" << t
-                << "\n";
+      std::cout << "[fuzz-exec] stopping after instantiation error\n";
       return;
     }
     interface.setModuleRunner(&instance);

From 34963c38e910cb37c345481ca58651e9abe96dae Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 16:59:49 -0700
Subject: [PATCH 37/42] work

---
 scripts/fuzz_opt.py           |  6 ++----
 src/tools/execution-results.h | 33 ++++++++++++++++++---------------
 2 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index e396284925d..ca3e7a12e93 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1663,9 +1663,6 @@ def handle(self, wasm):
 # The error shown in V8 when a module fails to instantiate.
 INSTANTIATE_ERROR = 'exception thrown: failed to instantiate module'
 
-# The logging Binaryen emits with fuzz-exec hits an instantiation error.
-BYN_INSTANTIATE_ERROR = '[fuzz-exec] stopping after instantiation error'
-
 
 # Fuzz in a near-identical manner to how we fuzz on ClusterFuzz. This is mainly
 # to see that fuzzing that way works properly (it likely won't catch anything
@@ -1816,7 +1813,8 @@ def handle(self, wasm):
         # see that that behavior remains even after optimizations.
         output = run_bynterp(wasm, args=['--fuzz-exec-before', f'--fuzz-exec-second={second_wasm}'])
 
-        if BYN_INSTANTIATE_ERROR in output:
+        # Check if we trapped during instantiation.
+        if traps_in_instantiation(output);
             # We may fail to instantiate the modules for valid reasons, such as
             # an active segment being out of bounds. There is no point to
             # continue in such cases, as no exports are called.
diff --git a/src/tools/execution-results.h b/src/tools/execution-results.h
index 243ff262594..62e968fbb8c 100644
--- a/src/tools/execution-results.h
+++ b/src/tools/execution-results.h
@@ -290,21 +290,29 @@ struct ExecutionResults {
   // link with it (like fuzz_shell's second module).
   void get(Module& wasm, Module* second = nullptr) {
     try {
-      // Run the first module.
+      // Instantiate the first module.
       LoggingExternalInterface interface(loggings, wasm);
       auto instance = std::make_shared<ModuleRunner>(wasm, &interface);
-      runModule(wasm, *instance, interface);
 
+      // Instantiate the second, if there is one (we instantiate both before
+      // running anything, so that we match the behavior of fuzz_shell.js).
+      std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances;
+      std::unique_ptr<LoggingExternalInterface> secondInterface;
+      std::shared_ptr<ModuleRunner> secondInstance;
       if (second) {
-        // Link and run the second module.
-        std::cout << "[fuzz-exec] running second module\n";
-        std::map<Name, std::shared_ptr<ModuleRunner>> linkedInstances;
+        // Link and instantiate the second module.
         linkedInstances["primary"] = instance;
-        LoggingExternalInterface secondInterface(
+        secondInterface = std::make_unique<LoggingExternalInterface>(
           loggings, *second, linkedInstances);
-        auto secondInstance = std::make_shared<ModuleRunner>(
-          *second, &secondInterface, linkedInstances);
-        runModule(*second, *secondInstance, secondInterface);
+        secondInstance = std::make_shared<ModuleRunner>(
+          *second, secondInterface.get(), linkedInstances);
+      }
+
+      // Run.
+      runModule(wasm, *instance, interface);
+      if (second) {
+        std::cout << "[fuzz-exec] running second module\n";
+        runModule(*second, *secondInstance, *secondInterface);
       }
     } catch (const TrapException&) {
       // May throw in instance creation (init of offsets).
@@ -322,12 +330,7 @@ struct ExecutionResults {
     // This is not an optimization: we want to execute anything, even relaxed
     // SIMD instructions.
     instance.setRelaxedBehavior(ModuleRunner::RelaxedBehavior::Execute);
-    try {
-      instance.instantiate();
-    } catch (const TrapException& t) {
-      std::cout << "[fuzz-exec] stopping after instantiation error\n";
-      return;
-    }
+    instance.instantiate();
     interface.setModuleRunner(&instance);
     // execute all exported methods (that are therefore preserved through
     // opts)

From 52781b25769183a702acf1645c056b9ebe4e5abd Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Mon, 6 Oct 2025 17:00:46 -0700
Subject: [PATCH 38/42] work

---
 scripts/fuzz_opt.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index ca3e7a12e93..a0469c73920 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1814,7 +1814,7 @@ def handle(self, wasm):
         output = run_bynterp(wasm, args=['--fuzz-exec-before', f'--fuzz-exec-second={second_wasm}'])
 
         # Check if we trapped during instantiation.
-        if traps_in_instantiation(output);
+        if traps_in_instantiation(output):
             # We may fail to instantiate the modules for valid reasons, such as
             # an active segment being out of bounds. There is no point to
             # continue in such cases, as no exports are called.

From 3885f4444bab422d72313074c4408bbe42115d12 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Tue, 7 Oct 2025 08:50:49 -0700
Subject: [PATCH 39/42] work

---
 src/tools/execution-results.h | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/tools/execution-results.h b/src/tools/execution-results.h
index 62e968fbb8c..ce4802a6289 100644
--- a/src/tools/execution-results.h
+++ b/src/tools/execution-results.h
@@ -293,6 +293,7 @@ struct ExecutionResults {
       // Instantiate the first module.
       LoggingExternalInterface interface(loggings, wasm);
       auto instance = std::make_shared<ModuleRunner>(wasm, &interface);
+      instantiate(*instance, interface);
 
       // Instantiate the second, if there is one (we instantiate both before
       // running anything, so that we match the behavior of fuzz_shell.js).
@@ -306,13 +307,14 @@ struct ExecutionResults {
           loggings, *second, linkedInstances);
         secondInstance = std::make_shared<ModuleRunner>(
           *second, secondInterface.get(), linkedInstances);
+        instantiate(*secondInstance, *secondInterface);
       }
 
       // Run.
-      runModule(wasm, *instance, interface);
+      callExports(wasm, *instance);
       if (second) {
         std::cout << "[fuzz-exec] running second module\n";
-        runModule(*second, *secondInstance, *secondInterface);
+        callExports(*second, *secondInstance);
       }
     } catch (const TrapException&) {
       // May throw in instance creation (init of offsets).
@@ -324,14 +326,17 @@ struct ExecutionResults {
     }
   }
 
-  void runModule(Module& wasm,
-                 ModuleRunner& instance,
-                 LoggingExternalInterface& interface) {
+  void instantiate(ModuleRunner& instance,
+                   LoggingExternalInterface& interface) {
     // This is not an optimization: we want to execute anything, even relaxed
     // SIMD instructions.
     instance.setRelaxedBehavior(ModuleRunner::RelaxedBehavior::Execute);
     instance.instantiate();
     interface.setModuleRunner(&instance);
+  }
+
+  void callExports(Module& wasm,
+                   ModuleRunner& instance) {
     // execute all exported methods (that are therefore preserved through
     // opts)
     for (auto& exp : wasm.exports) {

From 9b471e24d88ff0e7d43095a4e54d270bd45ad017 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Tue, 7 Oct 2025 08:54:09 -0700
Subject: [PATCH 40/42] work

---
 src/tools/execution-results.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/tools/execution-results.h b/src/tools/execution-results.h
index ce4802a6289..1b65ababb90 100644
--- a/src/tools/execution-results.h
+++ b/src/tools/execution-results.h
@@ -335,8 +335,7 @@ struct ExecutionResults {
     interface.setModuleRunner(&instance);
   }
 
-  void callExports(Module& wasm,
-                   ModuleRunner& instance) {
+  void callExports(Module& wasm, ModuleRunner& instance) {
     // execute all exported methods (that are therefore preserved through
     // opts)
     for (auto& exp : wasm.exports) {

From 4031f8d67c5ab5eedba2ce4179e4b4eeb201c603 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Tue, 7 Oct 2025 14:13:11 -0700
Subject: [PATCH 41/42] fix

---
 scripts/fuzz_opt.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index a0469c73920..36e8e199c71 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1674,7 +1674,7 @@ def handle(self, wasm):
 # like ClusterFuzz does, and that generates its own random data. If a bug is
 # caught here, it must be reduced manually.
 class ClusterFuzz(TestCaseHandler):
-    frequency = 1
+    frequency = 0.1
 
     # Use handle_pair over handle because we don't use these wasm files anyhow,
     # we generate our own using run.py. If we used handle, we'd be called twice
@@ -1780,7 +1780,9 @@ def ensure(self):
 # anything. This is similar to Split(), but rather than split a wasm file into
 # two and link them at runtime, this starts with two separate wasm files.
 class Two(TestCaseHandler):
-    frequency = 1 # 0.5
+    # Run at relatively high priority, as this is the main place we check cross-
+    # module interactions.
+    frequency = 1
 
     def handle(self, wasm):
         # Generate a second wasm file, unless we were given one (useful during

From c2d3c38e4fbba13aaab1fe8e776c448fc8f95911 Mon Sep 17 00:00:00 2001
From: Alon Zakai <azakai@google.com>
Date: Tue, 7 Oct 2025 15:56:08 -0700
Subject: [PATCH 42/42] feedback: simplify

---
 scripts/fuzz_opt.py | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index 36e8e199c71..56dc2af28de 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -1866,21 +1866,10 @@ def handle(self, wasm):
         if output == IGNORE:
             return
 
-        if output.startswith(INSTANTIATE_ERROR):
-            # Check 'primary' is not in the V8 error. That might indicate a
-            # problem in the imports of --fuzz-import. To do this, run the d8
-            # command directly, without the usual filtering of run_d8_wasm.
-            cmd = [shared.V8] + shared.V8_OPTS + get_v8_extra_flags() + [
-                get_fuzz_shell_js(),
-                '--',
-                wasm,
-                second_wasm
-            ]
-            out = run(cmd)
-            assert '"primary"' not in out, out
-
-            note_ignored_vm_run('Two-V8 instantiate error')
-            return
+        # We ruled out things we must ignore, like host limitations, and also
+        # exited earlier on a deterministic instantiation error, so there should
+        # be no such error in V8.
+        assert not output.startswith(INSTANTIATE_ERROR)
 
         output = fix_output(output)